From e89bb503cf4b22ac16054181f498df3bca592bb8 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Wed, 9 Oct 2024 22:35:01 -0400 Subject: [PATCH 01/55] Starting to add new seika version test. --- CMakeLists.txt | 43 ++++------------------------- seika/CMakeLists.txt | 42 +++++++++++++++++++++++++++++ seika/assert.h | 2 ++ seika/audio/audio_manager.h | 2 -- seika/version_info.h | 2 +- seika1/CMakeLists.txt | 32 ++++++++++++++++++++++ seika1/defines.h | 54 +++++++++++++++++++++++++++++++++++++ seika1/seika.c | 1 + seika1/seika.h | 1 + 9 files changed, 138 insertions(+), 41 deletions(-) create mode 100644 seika/CMakeLists.txt create mode 100644 seika1/CMakeLists.txt create mode 100644 seika1/defines.h create mode 100644 seika1/seika.c create mode 100644 seika1/seika.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 84c3fd7..9545718 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.27.0) set(CMAKE_C_STANDARD 11) -project(seika C) +project(seika-framework C) option(IS_CI_BUILD "" OFF) option(SEIKA_STATIC_LIB "Make seika and dependent libs static" OFF) @@ -10,44 +10,11 @@ option(SEIKA_STATIC_LIB "Make seika and dependent libs static" OFF) set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) -if (CMAKE_C_COMPILER_ID STREQUAL "MSVC") - list(APPEND flags "/W3" "/Zc:preprocessor") -elseif (APPLE) - list(APPEND flags "-Wfatal-errors" "-Wall" "-Wextra" "-Wno-write-strings" "-Wno-deprecated-declarations" - "-Wno-unused-variable" "-Wno-bad-function-cast" "-Wno-unused-parameter" "-Wno-missing-field-initializers") -else () - list(APPEND flags "-std=c11" "-Wfatal-errors" "-Wall" "-Wextra" "-Wno-write-strings" "-Wno-deprecated-declarations" - "-Wno-unused-variable" "-Wno-cast-function-type" "-Wno-unused-parameter" "-Wno-missing-field-initializers") -endif () - -file(GLOB_RECURSE SEIKA_SRC seika/*.c seika/*.h) -add_library(${PROJECT_NAME} STATIC ${SEIKA_SRC}) -target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) - #--- Dependencies ---# include(Dependencies.cmake) -#--- Link ---# -if (CMAKE_C_COMPILER_ID STREQUAL "MSVC") - target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio ${SDL3_LIBRARY} freetype Ws2_32) -elseif (WIN32) - target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio -lmingw32 -static-libgcc ${SDL3_LIBRARY} freetype -lws2_32) -elseif (APPLE) - target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio -Xlinker ${SDL3_LIBRARY} freetype m) -else () - target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio -static-libgcc -Xlinker -export-dynamic ${SDL3_LIBRARY} freetype m) -endif () - -target_compile_options(${PROJECT_NAME} PUBLIC ${flags}) - -# Copy directories over that are needed to test -if (NOT IS_CI_BUILD) - add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy_directory - ${PROJECT_SOURCE_DIR}/test - $/test - ) -endif() +add_subdirectory(seika) +add_subdirectory(seika1) if ("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}") set(SK_IS_MAIN TRUE) @@ -57,6 +24,6 @@ endif() if (SK_IS_MAIN) # Create seika test exe - add_executable(${PROJECT_NAME}_test test/test.c) - target_link_libraries(${PROJECT_NAME}_test ${PROJECT_NAME} unity) + add_executable(seika_test test/test.c) + target_link_libraries(seika_test seika unity) endif() diff --git a/seika/CMakeLists.txt b/seika/CMakeLists.txt new file mode 100644 index 0000000..5f680a7 --- /dev/null +++ b/seika/CMakeLists.txt @@ -0,0 +1,42 @@ +cmake_minimum_required(VERSION 3.27.0) + +set(CMAKE_C_STANDARD 11) + +project(seika C) + +if (CMAKE_C_COMPILER_ID STREQUAL "MSVC") + list(APPEND flags "/W3" "/Zc:preprocessor") +elseif (APPLE) + list(APPEND flags "-Wfatal-errors" "-Wall" "-Wextra" "-Wno-write-strings" "-Wno-deprecated-declarations" + "-Wno-unused-variable" "-Wno-bad-function-cast" "-Wno-unused-parameter" "-Wno-missing-field-initializers") +else () + list(APPEND flags "-std=c11" "-Wfatal-errors" "-Wall" "-Wextra" "-Wno-write-strings" "-Wno-deprecated-declarations" + "-Wno-unused-variable" "-Wno-cast-function-type" "-Wno-unused-parameter" "-Wno-missing-field-initializers") +endif () + +file(GLOB_RECURSE SEIKA_SRC ./*.c ./*.h) +add_library(${PROJECT_NAME} STATIC ${SEIKA_SRC}) +target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) +target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../) + +#--- Link ---# +if (CMAKE_C_COMPILER_ID STREQUAL "MSVC") + target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio ${SDL3_LIBRARY} freetype Ws2_32) +elseif (WIN32) + target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio -lmingw32 -static-libgcc ${SDL3_LIBRARY} freetype -lws2_32) +elseif (APPLE) + target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio -Xlinker ${SDL3_LIBRARY} freetype m) +else () + target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio -static-libgcc -Xlinker -export-dynamic ${SDL3_LIBRARY} freetype m) +endif () + +target_compile_options(${PROJECT_NAME} PUBLIC ${flags}) + +# Copy directories over that are needed to test +if (NOT IS_CI_BUILD) + add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_directory + ${PROJECT_SOURCE_DIR}/../test + $/../test + ) +endif() diff --git a/seika/assert.h b/seika/assert.h index 6392b8f..a85a0c4 100644 --- a/seika/assert.h +++ b/seika/assert.h @@ -2,6 +2,8 @@ extern "C" { #endif +#pragma once + #include #include #include diff --git a/seika/audio/audio_manager.h b/seika/audio/audio_manager.h index 8621ded..a9a7484 100644 --- a/seika/audio/audio_manager.h +++ b/seika/audio/audio_manager.h @@ -4,8 +4,6 @@ extern "C" { #endif -#include - #include "seika/defines.h" // --- Audio Manager --- // diff --git a/seika/version_info.h b/seika/version_info.h index 37e796d..c429fb7 100644 --- a/seika/version_info.h +++ b/seika/version_info.h @@ -4,6 +4,6 @@ #define SKA_VERSION_MAJOR 0 #define SKA_VERSION_MINOR 1 -#define SKA_VERSION_PATCH 6 +#define SKA_VERSION_PATCH 7 #define SKA_VERSION (SKA_MACRO_TO_STRING(SKA_VERSION_MAJOR) "." SKA_MACRO_TO_STRING(SKA_VERSION_MINOR) "." SKA_MACRO_TO_STRING(SKA_VERSION_PATCH)) diff --git a/seika1/CMakeLists.txt b/seika1/CMakeLists.txt new file mode 100644 index 0000000..bca6a7f --- /dev/null +++ b/seika1/CMakeLists.txt @@ -0,0 +1,32 @@ +cmake_minimum_required(VERSION 3.27.0) + +set(CMAKE_C_STANDARD 11) + +project(seika1 C) + +if (CMAKE_C_COMPILER_ID STREQUAL "MSVC") + list(APPEND flags "/W3" "/Zc:preprocessor") +elseif (APPLE) + list(APPEND flags "-Wfatal-errors" "-Wall" "-Wextra" "-Wno-write-strings" "-Wno-deprecated-declarations" + "-Wno-unused-variable" "-Wno-bad-function-cast" "-Wno-unused-parameter" "-Wno-missing-field-initializers") +else () + list(APPEND flags "-std=c11" "-Wfatal-errors" "-Wall" "-Wextra" "-Wno-write-strings" "-Wno-deprecated-declarations" + "-Wno-unused-variable" "-Wno-cast-function-type" "-Wno-unused-parameter" "-Wno-missing-field-initializers") +endif () + +file(GLOB_RECURSE SEIKA_SRC ./*.c ./*.h) +add_library(${PROJECT_NAME} STATIC ${SEIKA_SRC}) +target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) + +#--- Link ---# +if (CMAKE_C_COMPILER_ID STREQUAL "MSVC") + target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio ${SDL3_LIBRARY} freetype Ws2_32) +elseif (WIN32) + target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio -lmingw32 -static-libgcc ${SDL3_LIBRARY} freetype -lws2_32) +elseif (APPLE) + target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio -Xlinker ${SDL3_LIBRARY} freetype m) +else () + target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio -static-libgcc -Xlinker -export-dynamic ${SDL3_LIBRARY} freetype m) +endif () + +target_compile_options(${PROJECT_NAME} PUBLIC ${flags}) diff --git a/seika1/defines.h b/seika1/defines.h new file mode 100644 index 0000000..169b3d5 --- /dev/null +++ b/seika1/defines.h @@ -0,0 +1,54 @@ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +#include "version_info.h" + +// Compilation modes + +#define SKA_INCLUDE_RENDERING 1 +#define SKA_INCLUDE_THREAD 1 +#define SKA_INCLUDE_NETWORKING 1 +#define SKA_INCLUDE_DATA_STRUCTURES 1 +#define SKA_INCLUDE_ASSET 1 +#define SKA_INCLUDE_AUDIO 1 +#define SKA_INCLUDE_ECS 1 +#define SKA_INCLUDE_MATH 1 + +typedef size_t usize; + +typedef int16_t int16; +typedef int32_t int32; +typedef int64_t int64; + +typedef uint32_t uint32; +typedef uint64_t uint64; + +typedef float f32; +typedef double f64; + +#ifndef DEBUG +#define SKA_IF_DEBUG(STATEMENT) \ +do { STATEMENT } while(false) +#else +#define SE_DEBUG_MACRO(CONDITION, STATEMENT) \ +do {} while (false) +#endif + +// Used to define literal structs that are compatible from both c and c++ +#ifndef __cplusplus +#define SKA_STRUCT_LITERAL(STRUCT_NAME) \ +(STRUCT_NAME) +#else +#define SKA_STRUCT_LITERAL(STRUCT_NAME) +#endif + +#ifdef __cplusplus +} +#endif diff --git a/seika1/seika.c b/seika1/seika.c new file mode 100644 index 0000000..064d844 --- /dev/null +++ b/seika1/seika.c @@ -0,0 +1 @@ +#include "seika.h" diff --git a/seika1/seika.h b/seika1/seika.h new file mode 100644 index 0000000..6f70f09 --- /dev/null +++ b/seika1/seika.h @@ -0,0 +1 @@ +#pragma once From 268c111915fd1aecd9e640826d0037fb6a219677 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Wed, 9 Oct 2024 22:47:45 -0400 Subject: [PATCH 02/55] Updates. --- seika/CMakeLists.txt | 1 - seika1/CMakeLists.txt | 2 +- seika1/assert.c | 16 +++++ seika1/assert.h | 83 +++++++++++++++++++++++ seika1/logger.c | 153 ++++++++++++++++++++++++++++++++++++++++++ seika1/logger.h | 35 ++++++++++ seika1/macro_utils.h | 4 ++ seika1/memory.c | 25 +++++++ seika1/memory.h | 31 +++++++++ seika1/platform.c | 21 ++++++ seika1/platform.h | 25 +++++++ seika1/string.c | 153 ++++++++++++++++++++++++++++++++++++++++++ seika1/string.h | 27 ++++++++ seika1/version_info.h | 9 +++ 14 files changed, 583 insertions(+), 2 deletions(-) create mode 100644 seika1/assert.c create mode 100644 seika1/assert.h create mode 100644 seika1/logger.c create mode 100644 seika1/logger.h create mode 100644 seika1/macro_utils.h create mode 100644 seika1/memory.c create mode 100644 seika1/memory.h create mode 100644 seika1/platform.c create mode 100644 seika1/platform.h create mode 100644 seika1/string.c create mode 100644 seika1/string.h create mode 100644 seika1/version_info.h diff --git a/seika/CMakeLists.txt b/seika/CMakeLists.txt index 5f680a7..c763595 100644 --- a/seika/CMakeLists.txt +++ b/seika/CMakeLists.txt @@ -16,7 +16,6 @@ endif () file(GLOB_RECURSE SEIKA_SRC ./*.c ./*.h) add_library(${PROJECT_NAME} STATIC ${SEIKA_SRC}) -target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../) #--- Link ---# diff --git a/seika1/CMakeLists.txt b/seika1/CMakeLists.txt index bca6a7f..81d54de 100644 --- a/seika1/CMakeLists.txt +++ b/seika1/CMakeLists.txt @@ -16,7 +16,7 @@ endif () file(GLOB_RECURSE SEIKA_SRC ./*.c ./*.h) add_library(${PROJECT_NAME} STATIC ${SEIKA_SRC}) -target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) +target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../) #--- Link ---# if (CMAKE_C_COMPILER_ID STREQUAL "MSVC") diff --git a/seika1/assert.c b/seika1/assert.c new file mode 100644 index 0000000..7f90104 --- /dev/null +++ b/seika1/assert.c @@ -0,0 +1,16 @@ +#include "seika/assert.h" + +#include + +void ska_print_assert_err(const char* fmt, ...) { +#define SKA_PRINT_BUFFER_SIZE 496 + va_list args; + va_start(args, fmt); + char str[SKA_PRINT_BUFFER_SIZE]; + memset(str, 0, SKA_PRINT_BUFFER_SIZE); + ska_strncat(str, fmt, (sizeof(str) - strlen(str) - 1) ); + ska_strncat(str, "\n", (sizeof(str) - strlen(str) - 1) ); + vfprintf(stderr, str, args); + va_end(args); +#undef SKA_PRINT_BUFFER_SIZE +} diff --git a/seika1/assert.h b/seika1/assert.h new file mode 100644 index 0000000..a8c14ae --- /dev/null +++ b/seika1/assert.h @@ -0,0 +1,83 @@ +#ifdef __cplusplus +extern "C" { +#endif + +#pragma once + +#include +#include +#include + +#include "defines.h" +#include "platform.h" +#include "seika1/string.h" + +#define SKA_ASSERT_FAIL_EXIT_CODE (-1) + +void ska_print_assert_err(const char* fmt, ...); + +#define SKA_ASSERT(PREDICATE) \ +SKA_IF_DEBUG( \ +if (!(PREDICATE)) { \ +ska_print_assert_err("Assertion failed in file '%s' on line %u!\n", __FILE__, __LINE__); \ +if (se_platform_is_debugger_attached()) { SKA_TRIGGER_BREAKPOINT; } \ +exit(SKA_ASSERT_FAIL_EXIT_CODE); \ +} \ +) + +#define SKA_ASSERT_FMT(PREDICATE, FMT, ...) \ +SKA_IF_DEBUG( \ +if (!(PREDICATE)) { \ +ska_print_assert_err("Assertion failed in file '%s' on line %u!", __FILE__, __LINE__); \ +ska_print_assert_err(FMT, ##__VA_ARGS__); \ +if (se_platform_is_debugger_attached()) { SKA_TRIGGER_BREAKPOINT; } \ +exit(SKA_ASSERT_FAIL_EXIT_CODE); \ +} \ +) + +// Non-fatal asserts +#define SKA_ENSURE(PREDICATE) \ +SKA_IF_DEBUG( \ +if (!(PREDICATE)) { \ +static bool hasEnsureTriggered = false; \ +if (!hasEnsureTriggered) { \ +ska_print_assert_err("Ensure failed in file '%s' on line %u!\n", __FILE__, __LINE__); \ +if (se_platform_is_debugger_attached()) { SKA_TRIGGER_BREAKPOINT; } \ +hasEnsureTriggered = true; \ +} \ +} \ +) + +#define SKA_ENSURE_FMT(PREDICATE, FMT, ...) \ +SKA_IF_DEBUG( \ +if (!(PREDICATE)) { \ +static bool hasEnsureTriggered = false; \ +if (!hasEnsureTriggered) { \ +ska_print_assert_err("Ensure failed in file '%s' on line %u!", __FILE__, __LINE__); \ +ska_print_assert_err(FMT, ##__VA_ARGS__); \ +if (se_platform_is_debugger_attached()) { SKA_TRIGGER_BREAKPOINT; } \ +hasEnsureTriggered = true; \ +} \ +} \ +) + +#define SKA_ENSURE_ALWAYS(PREDICATE) \ +SKA_IF_DEBUG( \ +if (!(PREDICATE)) { \ +ska_print_assert_err("Ensure failed in file '%s' on line %u!\n", __FILE__, __LINE__); \ +if (se_platform_is_debugger_attached()) { SKA_TRIGGER_BREAKPOINT; } \ +} \ +) + +#define SKA_ENSURE_ALWAYS_FMT(PREDICATE, FMT, ...) \ +SKA_IF_DEBUG( \ +if (!(PREDICATE)) { \ +ska_print_assert_err("Ensure failed in file '%s' on line %u!", __FILE__, __LINE__); \ +ska_print_assert_err(FMT, ##__VA_ARGS__); \ +if (se_platform_is_debugger_attached()) { SKA_TRIGGER_BREAKPOINT; } \ +} \ +) + +#ifdef __cplusplus +} +#endif diff --git a/seika1/logger.c b/seika1/logger.c new file mode 100644 index 0000000..6111a2d --- /dev/null +++ b/seika1/logger.c @@ -0,0 +1,153 @@ +#include "logger.h" + +#include +#include +#include + +#include "seika/string.h" +#include "memory.h" + +#define SKA_LOGGER_MAX_QUEUED_MESSAGES 16 + +static SkaLogLevel currentLogLevel = SkaLogLevel_ERROR; +static char* queuedLogMessages[SKA_LOGGER_MAX_QUEUED_MESSAGES]; +static usize queuedLogMessagesCount = 0; +static usize queuedLogMessagesIndex = 0; + +void ska_logger_set_level(SkaLogLevel level) { + currentLogLevel = level; +} + +void ska_logger_error(const char* fmt, ...) { + va_list args; + va_start(args, fmt); + if (currentLogLevel <= SkaLogLevel_ERROR) { + char str[SKA_LOG_BUFFER_SIZE]; + const char* logLevelText = "[ERROR] "; + ska_strcpy(str, logLevelText); + ska_strncat(str, fmt, (sizeof(str) - strlen(str) - 1) ); + ska_strncat(str, "\n", (sizeof(str) - strlen(str) - 1) ); + vfprintf(stderr, str, args); + } + va_end(args); +} + +void ska_logger_warn(const char* fmt, ...) { + va_list args; + va_start(args, fmt); + if (currentLogLevel <= SkaLogLevel_WARN) { + char str[SKA_LOG_BUFFER_SIZE]; + const char* logLevelText = "[WARN] "; + ska_strcpy(str, logLevelText); + ska_strncat(str, fmt, (sizeof(str) - strlen(str) - 1) ); + ska_strncat(str, "\n", (sizeof(str) - strlen(str) - 1) ); + vprintf(str, args); + } + va_end(args); +} + +void ska_logger_info(const char* fmt, ...) { + va_list args; + va_start(args, fmt); + if (currentLogLevel <= SkaLogLevel_INFO) { + char str[SKA_LOG_BUFFER_SIZE]; + const char* logLevelText = "[INFO] "; + ska_strcpy(str, logLevelText); + ska_strncat(str, fmt, (sizeof(str) - strlen(str) - 1) ); + ska_strncat(str, "\n", (sizeof(str) - strlen(str) - 1) ); + vprintf(str, args); + } + va_end(args); +} + +void ska_logger_debug(const char* fmt, ...) { + va_list args; + va_start(args, fmt); + if (currentLogLevel <= SkaLogLevel_DEBUG) { + char str[SKA_LOG_BUFFER_SIZE]; + const char* logLevelText = "[DEBUG] "; + ska_strcpy(str, logLevelText); + ska_strncat(str, fmt, (sizeof(str) - strlen(str) - 1) ); + ska_strncat(str, "\n", (sizeof(str) - strlen(str) - 1) ); + vprintf(str, args); + } + va_end(args); +} + +void ska_logger_message(const char* fmt, ...) { + va_list args; + va_start(args, fmt); + char str[SKA_LOG_BUFFER_SIZE]; + memset(str, 0, SKA_LOG_BUFFER_SIZE); + ska_strncat(str, fmt, (sizeof(str) - strlen(str) - 1) ); + ska_strncat(str, "\n", (sizeof(str) - strlen(str) - 1) ); + vfprintf(stdout, str, args); + va_end(args); +} + +void ska_logger_internal_queue_message(const char* fmt, ...) { + va_list args; + va_start(args, fmt); + if (currentLogLevel <= SkaLogLevel_WARN) { + char str[SKA_LOG_BUFFER_SIZE]; + const char* logLevelText = "[WARN] "; + ska_strcpy(str, logLevelText); + ska_strncat(str, fmt, (sizeof(str) - strlen(str) - 1) ); + ska_strncat(str, "\n", (sizeof(str) - strlen(str) - 1) ); + vsnprintf(str, sizeof(str), str, args); + + usize currentIndex; + if (queuedLogMessagesIndex + 1 >= SKA_LOGGER_MAX_QUEUED_MESSAGES) { + queuedLogMessagesIndex = 0; + currentIndex = 0; + } else { + currentIndex = queuedLogMessagesIndex++; + queuedLogMessagesCount++; + } + // Freeing in case we looped around + SKA_MEM_FREE(queuedLogMessages[currentIndex]); + queuedLogMessages[currentIndex] = ska_strdup(str); + } + va_end(args); +} + +bool ska_logger_internal_print_queue() { + if (queuedLogMessagesCount > 0) { + for (usize i = 0; i < queuedLogMessagesCount; i++) { + ska_logger_message(queuedLogMessages[i]); + SKA_MEM_FREE(queuedLogMessages[i]); + queuedLogMessages[i] = NULL; + } + queuedLogMessagesCount = 0; + queuedLogMessagesIndex = 0; + return true; + } + return false; +} + +const char* ska_logger_get_log_level_string(SkaLogLevel level) { + switch (level) { + case SkaLogLevel_DEBUG: + return "debug"; + case SkaLogLevel_INFO: + return "info"; + case SkaLogLevel_WARN: + return "warn"; + case SkaLogLevel_ERROR: + return "error"; + } + return NULL; +} + +SkaLogLevel ska_logger_get_log_level_enum(const char* level) { + if (strcmp(level, "debug") == 0) { + return SkaLogLevel_DEBUG; + } else if (strcmp(level, "info") == 0) { + return SkaLogLevel_INFO; + } else if (strcmp(level, "warn") == 0) { + return SkaLogLevel_WARN; + } else if (strcmp(level, "error") == 0) { + return SkaLogLevel_ERROR; + } + return SkaLogLevel_ERROR; +} diff --git a/seika1/logger.h b/seika1/logger.h new file mode 100644 index 0000000..32c9abd --- /dev/null +++ b/seika1/logger.h @@ -0,0 +1,35 @@ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#ifndef SKA_LOG_BUFFER_SIZE +#define SKA_LOG_BUFFER_SIZE 512 +#endif + +typedef enum SkaLogLevel { + SkaLogLevel_DEBUG = 0, + SkaLogLevel_INFO = 1, + SkaLogLevel_WARN = 2, + SkaLogLevel_ERROR = 3 +} SkaLogLevel; + +void ska_logger_set_level(SkaLogLevel level); +void ska_logger_error(const char* fmt, ...); +void ska_logger_warn(const char* fmt, ...); +void ska_logger_info(const char* fmt, ...); +void ska_logger_debug(const char* fmt, ...); +void ska_logger_message(const char* fmt, ...); + +void ska_logger_internal_queue_message(const char* fmt, ...); +bool ska_logger_internal_print_queue(); + +const char* ska_logger_get_log_level_string(SkaLogLevel level); +SkaLogLevel ska_logger_get_log_level_enum(const char* level); + +#ifdef __cplusplus +} +#endif diff --git a/seika1/macro_utils.h b/seika1/macro_utils.h new file mode 100644 index 0000000..6041873 --- /dev/null +++ b/seika1/macro_utils.h @@ -0,0 +1,4 @@ +#pragma once + +#define SKA_MACRO_STRINGIFY(X) #X +#define SKA_MACRO_TO_STRING(X) SKA_MACRO_STRINGIFY(X) diff --git a/seika1/memory.c b/seika1/memory.c new file mode 100644 index 0000000..e4e41ef --- /dev/null +++ b/seika1/memory.c @@ -0,0 +1,25 @@ +#include "seika/memory.h" +#include "seika/assert.h" + +void* ska_mem_allocate(usize size) { + void* memory = calloc(1, size); + SKA_ASSERT_FMT(memory, "Out of memory or allocate failed!, size = %d", size); + return memory; +} + +void* ska_mem_allocate_c(usize blocks, usize size) { + void* memory = calloc(blocks, size); + SKA_ASSERT_FMT(memory, "Out of memory or allocate_c failed!, size = %d", size); + return memory; +} + +void* ska_mem_reallocate(void* memory, usize size) { + void* reallocatedMemory = realloc(memory, size); + SKA_ASSERT_FMT(reallocatedMemory, "Out of memory or realloc failed!, size = %d", size); + return reallocatedMemory; +} + +void ska_mem_free(void* memory) { + free(memory); + memory = NULL; +} diff --git a/seika1/memory.h b/seika1/memory.h new file mode 100644 index 0000000..677ac41 --- /dev/null +++ b/seika1/memory.h @@ -0,0 +1,31 @@ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "defines.h" + +#define SKA_MEM_ALLOCATE(DataType) \ +(DataType*) ska_mem_allocate(sizeof(DataType)) + +#define SKA_MEM_ALLOCATE_ARRAY(DataType, ArraySize) \ +(DataType*) ska_mem_allocate_c(ArraySize, sizeof(DataType)) + +#define SKA_MEM_ALLOCATE_SIZE(Size) \ +ska_mem_allocate(Size) + +#define SKA_MEM_ALLOCATE_SIZE_ZERO(Blocks, Size) \ +ska_mem_allocate_c(Blocks, Size) + +#define SKA_MEM_FREE(Memory) \ +ska_mem_free(Memory) + +void* ska_mem_allocate(usize size); +void* ska_mem_allocate_c(usize blocks, usize size); +void* ska_mem_reallocate(void* memory, usize size); +void ska_mem_free(void* memory); + +#ifdef __cplusplus +} +#endif diff --git a/seika1/platform.c b/seika1/platform.c new file mode 100644 index 0000000..9211d12 --- /dev/null +++ b/seika1/platform.c @@ -0,0 +1,21 @@ +#include "platform.h" + +#if defined(_WIN32) || defined(_WIN64) +#include +#elif defined(__APPLE__) +#include +#include +#elif defined(__linux__) +#include +#endif + +bool se_platform_is_debugger_attached() { +#if defined(_WIN32) || defined(_WIN64) + return IsDebuggerPresent(); +#elif defined(__APPLE__) + return (ptrace(PT_DENY_ATTACH, 0, 0, 0) == -1); +#elif defined(__linux__) + return (ptrace(PTRACE_TRACEME, 0, 1, 0) == -1); +#endif + return false; +} diff --git a/seika1/platform.h b/seika1/platform.h new file mode 100644 index 0000000..24b0ac7 --- /dev/null +++ b/seika1/platform.h @@ -0,0 +1,25 @@ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "stdbool.h" + +#if defined(_WIN32) || defined(_WIN64) // Windows +#define SKA_TRIGGER_BREAKPOINT __debugbreak() +#elif defined(__APPLE__) // macOS +#include +#define SKA_TRIGGER_BREAKPOINT raise(SIGTRAP) +#elif defined(__linux__) // Linux +#include +#define SKA_TRIGGER_BREAKPOINT raise(SIGTRAP) +#else +#define SKA_TRIGGER_BREAKPOINT +#endif + +bool se_platform_is_debugger_attached(); + +#ifdef __cplusplus +} +#endif diff --git a/seika1/string.c b/seika1/string.c new file mode 100644 index 0000000..0675da8 --- /dev/null +++ b/seika1/string.c @@ -0,0 +1,153 @@ +#include "seika/string.h" + +#include +#include +#include + +#include "seika/memory.h" + +#ifdef _MSC_VER +#pragma warning(disable : 4996) // for strcpy and strncat +#endif + +char* ska_strdup(const char* string) { + const usize string_length = strlen(string) + 1; + char* new_string = (char*)SKA_MEM_ALLOCATE_SIZE(string_length); + + if (new_string == NULL) { + return NULL; + } + + return strcpy(new_string, string); +} + +char* ska_strdup_from_memory(void* data, usize size) { + char* newString = (char*)SKA_MEM_ALLOCATE_SIZE(size + 1); + memcpy(newString, data, size); + newString[size] = '\0'; + return newString; +} + +void ska_strcpy(char* destination, const char* source) { + strcpy(destination, source); +} + +bool ska_strncpy(char* destination, usize sizeInBytes, const char* source, usize maxCount) { +#if defined(WIN32) || defined(WIN64) + if (strncpy_s(destination, sizeInBytes, source, maxCount) != 0) { + return false; + } +#else + strncpy(destination, source, maxCount); + if (maxCount > 0) { + destination[maxCount] = '\0'; + } +#endif + return true; +} + +void ska_strcat(char* destination, const char* source) { + strcat(destination, source); +} + +void ska_strncat(char* destination, const char* source, usize sizeInBytes) { + strncat(destination, source, sizeInBytes); +} + + +const char* ska_bool_to_string(bool value) { + return value == true ? "true" : "false"; +} + +char* ska_str_to_lower(char* str) { + for (char* p = str; *p; p++) { + *p = tolower(*p); + } + return str; +} + +char* ska_str_to_lower_and_underscore_whitespace(char* str) { + for (char* p = str; *p; p++) { + if (*p == ' ') { + *p = '_'; + } else { + *p = tolower(*p); + } + } + return str; +} + +unsigned char* ska_str_convert_string_to_unsigned_char(const char* value, usize* outSize) { + const usize stringLength = strlen(value); + *outSize = stringLength + 1; + unsigned char* returnValue = (unsigned char*)SKA_MEM_ALLOCATE_SIZE(*outSize); + for (usize i = 0; i < stringLength; i++) { + returnValue[i] = (unsigned char)value[i]; + } + returnValue[stringLength] = '\0'; + return returnValue; +} + +char* ska_str_trim(const char* value, char delimiter) { + char* newStr; + char* lastExt; + if (value == NULL) { + return NULL; + } + newStr = (char*)SKA_MEM_ALLOCATE_SIZE(strlen(value) + 1); + if (newStr == NULL) { + return NULL; + } + strcpy(newStr, value); + lastExt = strrchr(newStr, delimiter); + if (lastExt != NULL) { + *lastExt = '\0'; + } + return newStr; +} + +void ska_str_trim_by_size(const char* value, char* output, usize size) { + for (usize i = 0; i < size; i++) { + output[i] = value[i]; + } + output[size] = '\0'; +} + +char* ska_str_trim_and_replace(const char* value, char delimiter, const char* replacementValue) { +#define SE_TRIM_PATH_BUFFER 256 + char* newValue = ska_str_trim(value, delimiter); + char pathBuffer[SE_TRIM_PATH_BUFFER]; + strcpy(pathBuffer, newValue); + strcat(pathBuffer, replacementValue); + SKA_MEM_FREE(newValue); + newValue = ska_strdup(pathBuffer); + return newValue; +#undef SE_TRIM_PATH_BUFFER +} + +void ska_str_remove_char(char* string, char charToRemove) { + char* dest = string; + + while (*string) { + if (*string != charToRemove) { + *dest = *string; + dest++; + } + string++; + } + + *dest = '\0'; +} + +char* get_project_archive_name(const char* startingPath) { + if (startingPath == NULL) { + return NULL; + } + char* validPath = ska_str_trim(startingPath, '.'); + char pathBuffer[256]; + strcpy(pathBuffer, validPath); + strcat(pathBuffer, ".zip"); + SKA_MEM_FREE(validPath); + validPath = ska_strdup(pathBuffer); + return validPath; +} diff --git a/seika1/string.h b/seika1/string.h new file mode 100644 index 0000000..99bcdf7 --- /dev/null +++ b/seika1/string.h @@ -0,0 +1,27 @@ +#pragma once + +#include "defines.h" + +// Copies string and allocated new memory +char* ska_strdup(const char* string); +// Copies string from a void pointer and allocated new memory +char* ska_strdup_from_memory(void* data, usize size); +void ska_strcpy(char* destination, const char* source); +bool ska_strncpy(char* destination, usize sizeInBytes, const char* source, usize maxCount); +void ska_strcat(char* destination, const char* source); +void ska_strncat(char* destination, const char* source, usize sizeInBytes); +// Conversions + +const char* ska_bool_to_string(bool value); +char* ska_str_to_lower(); +char* ska_str_to_lower_and_underscore_whitespace(char* str); +unsigned char* ska_str_convert_string_to_unsigned_char(const char* value, usize* outSize); + +// Will trim text based on a delimiter and return the string before that +char* ska_str_trim(const char* value, char delimiter); +// Will trim text based on a size and return the string as the 'output' param +void ska_str_trim_by_size(const char* value, char* output, usize size); +// Same as 'ska_str_trim' but will replace the 'delimiter' with the 'replacementValue'. +char* ska_str_trim_and_replace(const char* value, char delimiter, const char* replacementValue); +// Removes all instances of the passed in char from the string +void ska_str_remove_char(char* string, char charToRemove); diff --git a/seika1/version_info.h b/seika1/version_info.h new file mode 100644 index 0000000..c429fb7 --- /dev/null +++ b/seika1/version_info.h @@ -0,0 +1,9 @@ +#pragma once + +#include "macro_utils.h" + +#define SKA_VERSION_MAJOR 0 +#define SKA_VERSION_MINOR 1 +#define SKA_VERSION_PATCH 7 + +#define SKA_VERSION (SKA_MACRO_TO_STRING(SKA_VERSION_MAJOR) "." SKA_MACRO_TO_STRING(SKA_VERSION_MINOR) "." SKA_MACRO_TO_STRING(SKA_VERSION_PATCH)) From f6042902e8b19dac555bf3c243227e241f639c97 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 10 Oct 2024 22:01:35 -0400 Subject: [PATCH 03/55] Test out some stuff. --- seika/assert.h | 3 ++- seika1/assert.h | 3 ++- seika1/defines.h | 6 +++++- seika1/platform.h | 2 +- seika1/string.h | 2 +- seika1/version_info.h | 2 +- 6 files changed, 12 insertions(+), 6 deletions(-) diff --git a/seika/assert.h b/seika/assert.h index a85a0c4..c3c7481 100644 --- a/seika/assert.h +++ b/seika/assert.h @@ -1,8 +1,9 @@ +#pragma once + #ifdef __cplusplus extern "C" { #endif -#pragma once #include #include diff --git a/seika1/assert.h b/seika1/assert.h index a8c14ae..dc92906 100644 --- a/seika1/assert.h +++ b/seika1/assert.h @@ -1,8 +1,9 @@ +#pragma once + #ifdef __cplusplus extern "C" { #endif -#pragma once #include #include diff --git a/seika1/defines.h b/seika1/defines.h index 169b3d5..d08caf5 100644 --- a/seika1/defines.h +++ b/seika1/defines.h @@ -8,10 +8,14 @@ extern "C" { #include #include -#include "version_info.h" +#include "seika/version_info.h" // Compilation modes +#ifndef SKA_RENDERING_MODULE +#define SKA_RENDERING_MODULE 1 +#endif + #define SKA_INCLUDE_RENDERING 1 #define SKA_INCLUDE_THREAD 1 #define SKA_INCLUDE_NETWORKING 1 diff --git a/seika1/platform.h b/seika1/platform.h index 24b0ac7..a63be05 100644 --- a/seika1/platform.h +++ b/seika1/platform.h @@ -4,7 +4,7 @@ extern "C" { #endif -#include "stdbool.h" +#include "seika/defines.h" #if defined(_WIN32) || defined(_WIN64) // Windows #define SKA_TRIGGER_BREAKPOINT __debugbreak() diff --git a/seika1/string.h b/seika1/string.h index 99bcdf7..b872934 100644 --- a/seika1/string.h +++ b/seika1/string.h @@ -1,6 +1,6 @@ #pragma once -#include "defines.h" +#include "seika/defines.h" // Copies string and allocated new memory char* ska_strdup(const char* string); diff --git a/seika1/version_info.h b/seika1/version_info.h index c429fb7..dd543ca 100644 --- a/seika1/version_info.h +++ b/seika1/version_info.h @@ -1,6 +1,6 @@ #pragma once -#include "macro_utils.h" +#include "seika/macro_utils.h" #define SKA_VERSION_MAJOR 0 #define SKA_VERSION_MINOR 1 From a1c583d23ff898bd339ea0720ec088806b02044b Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 10 Oct 2024 22:02:03 -0400 Subject: [PATCH 04/55] Updates. --- seika1/data_structures/array2d.c | 96 +++++++ seika1/data_structures/array2d.h | 20 ++ seika1/data_structures/array_list.c | 77 ++++++ seika1/data_structures/array_list.h | 32 +++ seika1/data_structures/array_utils.c | 32 +++ seika1/data_structures/array_utils.h | 24 ++ seika1/data_structures/hash_map.c | 264 +++++++++++++++++++ seika1/data_structures/hash_map.h | 59 +++++ seika1/data_structures/hash_map_string.c | 295 ++++++++++++++++++++++ seika1/data_structures/hash_map_string.h | 63 +++++ seika1/data_structures/queue.c | 60 +++++ seika1/data_structures/queue.h | 21 ++ seika1/data_structures/spatial_hash_map.c | 264 +++++++++++++++++++ seika1/data_structures/spatial_hash_map.h | 43 ++++ seika1/data_structures/static_array.h | 107 ++++++++ seika1/math/curve_float.c | 93 +++++++ seika1/math/curve_float.h | 33 +++ seika1/math/math.c | 176 +++++++++++++ seika1/math/math.h | 180 +++++++++++++ 19 files changed, 1939 insertions(+) create mode 100644 seika1/data_structures/array2d.c create mode 100644 seika1/data_structures/array2d.h create mode 100644 seika1/data_structures/array_list.c create mode 100644 seika1/data_structures/array_list.h create mode 100644 seika1/data_structures/array_utils.c create mode 100644 seika1/data_structures/array_utils.h create mode 100644 seika1/data_structures/hash_map.c create mode 100644 seika1/data_structures/hash_map.h create mode 100644 seika1/data_structures/hash_map_string.c create mode 100644 seika1/data_structures/hash_map_string.h create mode 100644 seika1/data_structures/queue.c create mode 100644 seika1/data_structures/queue.h create mode 100644 seika1/data_structures/spatial_hash_map.c create mode 100644 seika1/data_structures/spatial_hash_map.h create mode 100644 seika1/data_structures/static_array.h create mode 100644 seika1/math/curve_float.c create mode 100644 seika1/math/curve_float.h create mode 100644 seika1/math/math.c create mode 100644 seika1/math/math.h diff --git a/seika1/data_structures/array2d.c b/seika1/data_structures/array2d.c new file mode 100644 index 0000000..cd7d3ed --- /dev/null +++ b/seika1/data_structures/array2d.c @@ -0,0 +1,96 @@ +#include "array2d.h" + +#include + +#include "seika/memory.h" +#include "seika/assert.h" + +#define SKA_ARRAY2D_IS_COORD_INVALID(ARRAY2D, ROW, COL) ((int32)ROW >= ARRAY2D->size.w || (int32)COL >= ARRAY2D->size.h) + +SkaArray2D* ska_array2d_create(usize rows, usize cols, usize elementSize) { + SkaArray2D* newArray = SKA_MEM_ALLOCATE(SkaArray2D); + newArray->data = SKA_MEM_ALLOCATE_SIZE(cols * sizeof(void*)); + for (usize i = 0; i < cols; i++) { + newArray->data[i] = SKA_MEM_ALLOCATE_SIZE(rows * elementSize); + } + newArray->size = (SkaSize2Di){ .w = (int32)rows, .h = (int32)cols }; + newArray->elementSize = elementSize; + return newArray; +} + +void ska_array2d_destroy(SkaArray2D* array2d) { + for (int32 i = 0; i < array2d->size.h; i++) { + SKA_MEM_FREE(array2d->data[i]); + } + SKA_MEM_FREE(array2d->data); + SKA_MEM_FREE(array2d); +} + +void* ska_array2d_get(SkaArray2D* array2d, usize x, usize y) { + if (SKA_ARRAY2D_IS_COORD_INVALID(array2d, x, y)) { + return NULL; + } + return (void*)((char*)array2d->data[y] + x * array2d->elementSize); +} + +bool ska_array2d_set(SkaArray2D* array2d, usize x, usize y, void* newValue) { + if (SKA_ARRAY2D_IS_COORD_INVALID(array2d, x, y)) { + return false; + } + memcpy((void*)((char*)array2d->data[y] + x * array2d->elementSize), newValue, array2d->elementSize); + return true; +} + +void ska_array2d_resize(SkaArray2D* array2d, usize newX, usize newY) { + // Reallocate memory for data array + const usize newWidth = SKA_MATH_MAX(newX, 1); + const usize newHeight = SKA_MATH_MAX(newY, 1); + // Cache off old data + void** oldData = array2d->data; + const SkaSize2Di oldSize = array2d->size; + // Allocate data for all columns + array2d->data = SKA_MEM_ALLOCATE_SIZE(newHeight * sizeof(void*)); + // Iterate over new rows + for (usize i = 0; i < newHeight; i++) { + // Allocate data for new row + array2d->data[i] = SKA_MEM_ALLOCATE_SIZE(newX * array2d->elementSize); + if (i < (usize)oldSize.h) { + // Now copy old data + const usize bytesToCopy = SKA_MATH_MIN((usize)oldSize.w, newWidth) * array2d->elementSize; + memcpy(array2d->data[i], oldData[i], bytesToCopy); + } + } + + array2d->size = (SkaSize2Di){ .w = (int32)newX, .h = (int32)newY }; + + if (newX == 0 && newY == 0) { + ska_array2d_reset(array2d); + } + + for (usize i = 0; i < (usize)oldSize.h; i++) { + SKA_MEM_FREE(oldData[i]); + } + SKA_MEM_FREE(oldData); +} + +void ska_array2d_clear(SkaArray2D* array2d) { + ska_array2d_resize(array2d, 0, 0); +} + +void ska_array2d_reset(SkaArray2D* array2d) { + ska_array2d_reset_default(array2d, NULL); +} + +void ska_array2d_reset_default(SkaArray2D* array2d, void* defaultValue) { + if (defaultValue) { + for (int32 y = 0; y < array2d->size.h; y++) { + for (int32 x = 0; x < array2d->size.w; x++) { + ska_array2d_set(array2d, x, y, defaultValue); + } + } + } else { + for (int32 i = 0; i < array2d->size.h; i++) { + memset(array2d->data[i], 0, array2d->size.w * array2d->elementSize); + } + } +} diff --git a/seika1/data_structures/array2d.h b/seika1/data_structures/array2d.h new file mode 100644 index 0000000..f2c9cc0 --- /dev/null +++ b/seika1/data_structures/array2d.h @@ -0,0 +1,20 @@ +#pragma once + +#include "seika/math/math.h" + +typedef struct SkaArray2D { + void** data; + SkaSize2Di size; // w = rows, h = columns + usize elementSize; +} SkaArray2D; + +SkaArray2D* ska_array2d_create(usize rows, usize cols, usize elementSize); +void ska_array2d_destroy(SkaArray2D* array2d); +void* ska_array2d_get(SkaArray2D* array2d, usize x, usize y); +bool ska_array2d_set(SkaArray2D* array2d, usize x, usize y, void* newValue); +void ska_array2d_resize(SkaArray2D* array2d, usize newX, usize newY); +void ska_array2d_clear(SkaArray2D* array2d); +// Maintains elements in the arrays but zeroes out data +void ska_array2d_reset(SkaArray2D* array2d); +// Maintains elements in the arrays but copy memory from the passed in default value +void ska_array2d_reset_default(SkaArray2D* array2d, void* defaultValue); diff --git a/seika1/data_structures/array_list.c b/seika1/data_structures/array_list.c new file mode 100644 index 0000000..0e94f17 --- /dev/null +++ b/seika1/data_structures/array_list.c @@ -0,0 +1,77 @@ +#include "array_list.h" + +#include + +#include "seika/memory.h" +#include "seika/assert.h" + +#define SKA_ARRAY_LIST_DEFAULT_CAPACITY 16 + +SkaArrayList* ska_array_list_create_default_capacity(usize valueSize) { + return ska_array_list_create(valueSize, SKA_ARRAY_LIST_DEFAULT_CAPACITY); +} + +SkaArrayList* ska_array_list_create(usize valueSize, usize initialCapacity) { + SkaArrayList* newList = SKA_MEM_ALLOCATE(SkaArrayList); + newList->data = SKA_MEM_ALLOCATE_SIZE(initialCapacity * valueSize); + newList->valueSize = valueSize; + newList->capacity = initialCapacity; + newList->initialCapacity = initialCapacity; + return newList; +} + +void ska_array_list_destroy(SkaArrayList* list) { + SKA_MEM_FREE(list->data); + SKA_MEM_FREE(list); +} + +void ska_array_list_push_back(SkaArrayList* list, const void* value) { + if (list->size >= list->capacity) { + list->capacity *= 2; + list->data = ska_mem_reallocate(list->data, list->capacity * list->valueSize); + } + memcpy((char*)list->data + list->size * list->valueSize, value, list->valueSize); + list->size++; +} + +void* ska_array_list_get(SkaArrayList* list, usize index) { + SKA_ASSERT_FMT(index < list->size, "Attempting to access out of bounds index '%d", index); + return (char*)list->data + index * list->valueSize; +} + +bool ska_array_list_remove(SkaArrayList* list, const void* value) { + usize index = 0; + while (index < list->size) { + if (memcmp((char*)list->data + index * list->valueSize, value, list->valueSize) == 0) { + // Found the element, remove it + for (usize i = index + 1; i < list->size; ++i) { + memcpy((char*)list->data + (i - 1) * list->valueSize, (char*)list->data + i * list->valueSize, list->valueSize); + } + list->size--; + return true; + } else { + index++; + } + } + return false; +} + +bool ska_array_list_remove_by_index(SkaArrayList* list, usize index) { + if (index < list->size) { + // Shift elements after the removed element + for (usize i = index + 1; i < list->size; ++i) { + memcpy((char*)list->data + (i - 1) * list->valueSize, (char*)list->data + i * list->valueSize, list->valueSize); + } + list->size--; + return true; + } + return false; +} + +bool ska_array_list_is_empty(SkaArrayList *list) { + return list->size == 0; +} + +void ska_array_list_clear(SkaArrayList *list) { + list->size = 0; +} diff --git a/seika1/data_structures/array_list.h b/seika1/data_structures/array_list.h new file mode 100644 index 0000000..d03a6ff --- /dev/null +++ b/seika1/data_structures/array_list.h @@ -0,0 +1,32 @@ +#pragma once + +#include "seika/defines.h" + +#define SKA_ARRAY_LIST_GET_ARRAY(LIST, TYPE) ((TYPE*)((LIST)->data)) +#define SKA_ARRAY_LIST_FOR_EACH(LIST, TYPE, VALUE) for(TYPE* VALUE = SKA_ARRAY_LIST_GET_ARRAY(LIST, TYPE), *VALUE##_end = VALUE + (LIST)->size; VALUE < VALUE##_end; VALUE++) + +// Generic array list, use 'ska_array_list_create' to allocate on the heap +typedef struct SkaArrayList { + void* data; + usize valueSize; // Size of each element of the data + usize size; // How many elements are in the array + usize capacity; // Max elements allowed in array before resizing + usize initialCapacity; // Min capacity for the array list +} SkaArrayList; + +// Will create a new array list with all it's element values set to the passed in 'valueSize' +SkaArrayList* ska_array_list_create_default_capacity(usize valueSize); +SkaArrayList* ska_array_list_create(usize valueSize, usize initialCapacity); +// Will complete destroy the array list freeing up all its memory +void ska_array_list_destroy(SkaArrayList* list); +// Inserts an item at the end of the list +void ska_array_list_push_back(SkaArrayList* list, const void* value); +// Returns an item from the list from specified index +void* ska_array_list_get(SkaArrayList* list, usize index); +// Removes the first item from the list who is equal to the passed in value +bool ska_array_list_remove(SkaArrayList* list, const void* value); +bool ska_array_list_remove_by_index(SkaArrayList* list, usize index); +// Returns true if the array list size == 0 +bool ska_array_list_is_empty(SkaArrayList *list); +// Will remove all items from the array list +void ska_array_list_clear(SkaArrayList *list); diff --git a/seika1/data_structures/array_utils.c b/seika1/data_structures/array_utils.c new file mode 100644 index 0000000..5eafadf --- /dev/null +++ b/seika1/data_structures/array_utils.c @@ -0,0 +1,32 @@ +#include "array_utils.h" + +static inline void ska_array_utils_swap(int32* xp, int32* yp) { + int32 temp = *xp; + *xp = *yp; + *yp = temp; +} + +// Function to perform Selection Sort +void ska_array_utils_selection_sort_int(int32 arr[], int32 arraySize) { + int32 min_idx; + + // One by one move boundary of unsorted subarray + for (int32 i = 0; i < arraySize - 1; i++) { + + // Find the minimum element in unsorted array + min_idx = i; + for (int32 j = i + 1; j < arraySize; j++) { + if (arr[j] < arr[min_idx]) { + min_idx = j; + } + } + + // Swap the found minimum element + // with the first element + ska_array_utils_swap(&arr[min_idx], &arr[i]); + } +} + +void ska_array_utils_remove_item_uint32(uint32 array[], usize* size, uint32 item, uint32 emptyValue) { + SKA_ARRAY_UTILS_REMOVE_ARRAY_ITEM(array, *size, item, emptyValue); +} diff --git a/seika1/data_structures/array_utils.h b/seika1/data_structures/array_utils.h new file mode 100644 index 0000000..14cb3c3 --- /dev/null +++ b/seika1/data_structures/array_utils.h @@ -0,0 +1,24 @@ +#pragma once + +#include "seika/defines.h" + +#define SKA_ARRAY_UTILS_REMOVE_ARRAY_ITEM(ARRAY, ARRAY_SIZE, ELEMENT, EMPTY_VALUE) \ +{ \ +const usize temp_arac_size = (ARRAY_SIZE); \ +for (usize temp_arac_loop_index = 0; temp_arac_loop_index < temp_arac_size; temp_arac_loop_index++) { \ +if (ARRAY[temp_arac_loop_index] == ELEMENT) { \ +ARRAY[temp_arac_loop_index] = ARRAY[temp_arac_loop_index + 1]; \ +ARRAY[temp_arac_loop_index + 1] = EMPTY_VALUE; \ +(ARRAY_SIZE)--; \ +} \ +if (ARRAY[temp_arac_loop_index] == EMPTY_VALUE && temp_arac_loop_index + 1 < temp_arac_size) { \ +ARRAY[temp_arac_loop_index] = ARRAY[temp_arac_loop_index + 1]; \ +ARRAY[temp_arac_loop_index + 1] = EMPTY_VALUE; \ +} \ +} \ +} + +// Function to perform Selection Sort +void ska_array_utils_selection_sort_int(int32 arr[], int32 arraySize); + +void ska_array_utils_remove_item_uint32(uint32 array[], usize* size, uint32 item, uint32 emptyValue); diff --git a/seika1/data_structures/hash_map.c b/seika1/data_structures/hash_map.c new file mode 100644 index 0000000..3c77f5f --- /dev/null +++ b/seika1/data_structures/hash_map.c @@ -0,0 +1,264 @@ +#include "hash_map.h" + +#include + +#include "seika/memory.h" +#include "seika/assert.h" + +static usize se_default_hash(void* raw_key, usize key_size); +static int32 se_default_compare(void* first_key, void* second_key, usize key_size); + +static SkaHashMapNode* hash_map_create_node(SkaHashMap* hashMap, void* key, void* value, SkaHashMapNode* next); +static void hash_map_destroy_node(SkaHashMapNode* node); + +static bool hash_map_push_front(SkaHashMap* hashMap, usize index, void* key, void* value); +static void hash_map_grow_if_needed(SkaHashMap* hashMap); +static void hash_map_shrink_if_needed(SkaHashMap* hashMap); +static void hash_map_allocate(SkaHashMap* hashMap, usize capacity); +static void hash_map_resize(SkaHashMap* hashMap, usize capacity); + +SkaHashMap* ska_hash_map_create(usize keySize, usize valueSize, usize capacity) { + SkaHashMap* map = (SkaHashMap*) SKA_MEM_ALLOCATE_SIZE(sizeof(SkaHashMap)); + map->keySize = keySize; + map->valueSize = valueSize; + map->size = 0; + map->hashFunc = se_default_hash; + map->compareFunc = se_default_compare; + hash_map_allocate(map, capacity); + return map; +} + +SkaHashMapNode* hash_map_create_node(SkaHashMap* hashMap, void* key, void* value, SkaHashMapNode* next) { + SkaHashMapNode* node = (SkaHashMapNode*) SKA_MEM_ALLOCATE(SkaHashMapNode); + node->key = SKA_MEM_ALLOCATE_SIZE(hashMap->keySize); + node->value = SKA_MEM_ALLOCATE_SIZE(hashMap->valueSize); + memcpy(node->key, key, hashMap->keySize); + memcpy(node->value, value, hashMap->valueSize); + node->next = next; + return node; +} + +bool ska_hash_map_destroy(SkaHashMap* hashMap) { + SkaHashMapNode* node = NULL; + SkaHashMapNode* next = NULL; + for (usize chain = 0; chain < hashMap->capacity; chain++) { + node = hashMap->nodes[chain]; + while (node != NULL) { + next = node->next; + hash_map_destroy_node(node); + node = next; + } + } + + SKA_MEM_FREE(hashMap); + + return true; +} + +bool hash_map_push_front(SkaHashMap* hashMap, usize index, void* key, void* value) { + hashMap->nodes[index] = hash_map_create_node(hashMap, key, value, hashMap->nodes[index]); + return hashMap->nodes[index] != NULL; +} + +bool ska_hash_map_add(SkaHashMap* hashMap, void* key, void* value) { + SKA_ASSERT(hashMap != NULL); + SKA_ASSERT(key != NULL); + SKA_ASSERT(value != NULL); + + hash_map_grow_if_needed(hashMap); + + usize index = hashMap->hashFunc(key, hashMap->keySize) % hashMap->capacity; + if (ska_hash_map_has(hashMap, key)) { + SkaHashMapNode* node = hashMap->nodes[index]; + memcpy(node->value, value, hashMap->valueSize); + return true; // Updated Item + } + + if (!hash_map_push_front(hashMap, index, key, value)) { + return false; // Error + } + + hashMap->size++; + // Inserted + return true; +} + +bool ska_hash_map_has(SkaHashMap* hashMap, void* key) { + SKA_ASSERT(hashMap != NULL); + usize index = hashMap->hashFunc(key, hashMap->keySize) % hashMap->capacity; + for (SkaHashMapNode* node = hashMap->nodes[index]; node; node = node->next) { + if (hashMap->compareFunc(key, node->key, hashMap->keySize) == 0) { + return true; + } + } + return false; +} + +void* ska_hash_map_get(SkaHashMap* hashMap, void* key) { + SKA_ASSERT(hashMap != NULL); + usize index = hashMap->hashFunc(key, hashMap->keySize) % hashMap->capacity; + for (SkaHashMapNode* node = hashMap->nodes[index]; node; node = node->next) { + if (hashMap->compareFunc(key, node->key, hashMap->keySize) == 0) { + return node->value; + } + } + return NULL; +} + +bool ska_hash_map_erase(SkaHashMap* hashMap, void* key) { + SKA_ASSERT(hashMap != NULL); + SKA_ASSERT(key != NULL); + + usize index = hashMap->hashFunc(key, hashMap->keySize) % hashMap->capacity; + SkaHashMapNode* node = hashMap->nodes[index]; + for (SkaHashMapNode* previous = NULL; node; previous = node, node = node->next) { + if (hashMap->compareFunc(key, node->key, hashMap->keySize) == 0) { + if (previous != NULL) { + previous->next = node->next; + } else { + hashMap->nodes[index] = node->next; + } + + hash_map_destroy_node(node); + hashMap->size--; + + hash_map_shrink_if_needed(hashMap); + + return true; + } + } + + return false; +} + +void hash_map_grow_if_needed(SkaHashMap* hashMap) { + SKA_ASSERT_FMT(hashMap->size <= hashMap->capacity, "Hashmap size '%d' is bigger than its capacity '%d'!", hashMap->size, hashMap->capacity); + if (hashMap->size == hashMap->capacity) { + hash_map_resize(hashMap, hashMap->size * 2); + } +} + +void hash_map_shrink_if_needed(SkaHashMap* hashMap) { + SKA_ASSERT_FMT(hashMap->size <= hashMap->capacity, "Hashmap size '%d' is bigger than its capacity '%d'!", hashMap->size, hashMap->capacity); + usize shrinkCapacity = (usize) ((float) hashMap->capacity * SKA_HASH_MAP_SHRINK_THRESHOLD); + if (hashMap->size == shrinkCapacity) { + hash_map_resize(hashMap, shrinkCapacity); + } +} + +void hash_map_allocate(SkaHashMap* hashMap, usize capacity) { + hashMap->nodes = (SkaHashMapNode**)SKA_MEM_ALLOCATE_SIZE(capacity * sizeof(SkaHashMapNode*)); + memset(hashMap->nodes, 0, capacity * sizeof(SkaHashMapNode*)); + + hashMap->capacity = capacity; +} + +void hash_map_rehash(SkaHashMap* hashMap, SkaHashMapNode** oldNode, usize oldCapacity) { + for (usize chain = 0; chain < oldCapacity; chain++) { + for (SkaHashMapNode* node = oldNode[chain]; node != NULL;) { + SkaHashMapNode* next = node->next; + + usize newIndex = hashMap->hashFunc(node->key, hashMap->keySize) % hashMap->capacity; + node->next = hashMap->nodes[newIndex]; + hashMap->nodes[newIndex] = node; + + node = next; + } + } +} + +void hash_map_resize(SkaHashMap* hashMap, usize capacity) { + if (capacity < SKA_HASH_MAP_MIN_CAPACITY) { + if (hashMap->capacity > SKA_HASH_MAP_MIN_CAPACITY) { + capacity = SKA_HASH_MAP_MIN_CAPACITY; + } else { + // Do nothing since the passed in capacity is too low and the current map's capacity is already at min limit + return; + } + } + + SkaHashMapNode** oldNode = hashMap->nodes; + usize oldCapacity = hashMap->capacity; + hash_map_allocate(hashMap, capacity); + + hash_map_rehash(hashMap, oldNode, oldCapacity); + + SKA_MEM_FREE(oldNode); +} + +// --- Iterator --- // +SkaHashMapIterator ska_hash_map_iter_create(SkaHashMap* hashMap) { + // Get initial node if exists + SkaHashMapNode* initialNode = NULL; + usize initialIndex = 0; + for (usize chain = 0; chain < hashMap->capacity; chain++) { + SkaHashMapNode* node = hashMap->nodes[chain]; + if (node != NULL) { + initialNode = node; + initialIndex = chain + 1; + break; + } + } + usize iteratorCount = initialNode != NULL ? 1 : 0; + SkaHashMapIterator iterator = { .count = iteratorCount, .end = hashMap->capacity, .index = initialIndex, .pair = initialNode }; + return iterator; +} + +bool ska_hash_map_iter_is_valid(SkaHashMap* hashMap, SkaHashMapIterator* iterator) { + return iterator->pair != NULL && iterator->count <= hashMap->size; +} + +void ska_hash_map_iter_advance(SkaHashMap* hashMap, SkaHashMapIterator* iterator) { + if (ska_hash_map_iter_is_valid(hashMap, iterator)) { + if (iterator->pair->next != NULL) { + iterator->pair = iterator->pair->next; + iterator->count++; + return; + } + + // Search nodes array if there are no more linked pairs + for (usize chain = iterator->index; chain < hashMap->capacity; chain++) { + SkaHashMapNode* node = hashMap->nodes[chain]; + if (node != NULL) { + iterator->pair = node; + iterator->index = chain + 1; + iterator->count++; + return; + } + } + } + // Invalidate iterator since we've reached the end + iterator->pair = NULL; +} + +// Misc +usize se_default_hash(void* raw_key, usize key_size) { + // djb2 string hashing algorithm + // sstp://www.cse.yorku.ca/~oz/hash.ssml + usize byte; + usize hash = 5381; + char* key = (char*) raw_key; + + for (byte = 0; byte < key_size; ++byte) { + // (hash << 5) + hash = hash * 33 + hash = ((hash << 5) + hash) ^ key[byte]; + } + + return hash; +} + +int32 se_default_compare(void* first_key, void* second_key, usize key_size) { + return memcmp(first_key, second_key, key_size); +} + +void hash_map_destroy_node(SkaHashMapNode* node) { + SKA_ASSERT(node != NULL); + SKA_ASSERT(node->value != NULL); + SKA_ASSERT(node->key != NULL); + + SKA_MEM_FREE(node->key); + node->key = NULL; + SKA_MEM_FREE(node->value); + node->value = NULL; + SKA_MEM_FREE(node); +} diff --git a/seika1/data_structures/hash_map.h b/seika1/data_structures/hash_map.h new file mode 100644 index 0000000..852c99a --- /dev/null +++ b/seika1/data_structures/hash_map.h @@ -0,0 +1,59 @@ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +#include "seika/defines.h" + +#define SKA_HASH_MAP_SHRINK_THRESHOLD 0.25f +#define SKA_HASH_MAP_MIN_CAPACITY 8 + +#define SKA_HASH_MAP_FOR_EACH(HASH_MAP, ITER_NAME) \ +for (SkaHashMapIterator ITER_NAME = ska_hash_map_iter_create(HASH_MAP); ska_hash_map_iter_is_valid(HASH_MAP, &(ITER_NAME)); ska_hash_map_iter_advance(HASH_MAP, &(ITER_NAME))) + +typedef usize (*SkaHashFunc) (void*, usize); +typedef int32 (*SkaCompareFunc) (void*, void*, usize); + +typedef struct SkaHashMapNode { + struct SkaHashMapNode* next; + void* key; + void* value; +} SkaHashMapNode; + +typedef struct SkaHashMap { + usize keySize; + usize valueSize; + usize capacity; + usize size; + SkaHashFunc hashFunc; + SkaCompareFunc compareFunc; + SkaHashMapNode** nodes; +} SkaHashMap; + +typedef struct SkaHashMapIterator { + usize count; + usize end; + usize index; + SkaHashMapNode* pair; +} SkaHashMapIterator; + +// Generic hash map methods +SkaHashMap* ska_hash_map_create(usize keySize, usize valueSize, usize capacity); +bool ska_hash_map_destroy(SkaHashMap* hashMap); +bool ska_hash_map_add(SkaHashMap* hashMap, void* key, void* value); +void* ska_hash_map_get(SkaHashMap* hashMap, void* key); +bool ska_hash_map_has(SkaHashMap* hashMap, void* key); +bool ska_hash_map_erase(SkaHashMap* hashMap, void* key); + +// Iterator +SkaHashMapIterator ska_hash_map_iter_create(SkaHashMap* hashMap); +bool ska_hash_map_iter_is_valid(SkaHashMap* hashMap, SkaHashMapIterator* iterator); +void ska_hash_map_iter_advance(SkaHashMap* hashMap, SkaHashMapIterator* iterator); + +#ifdef __cplusplus +} +#endif diff --git a/seika1/data_structures/hash_map_string.c b/seika1/data_structures/hash_map_string.c new file mode 100644 index 0000000..f090614 --- /dev/null +++ b/seika1/data_structures/hash_map_string.c @@ -0,0 +1,295 @@ +#include "hash_map_string.h" + +#include + +#include "seika/string.h" +#include "seika/memory.h" +#include "seika/assert.h" + +static usize ska_default_hash_string(const char* raw_key); +static int32 ska_default_compare_string(const char* first_key, const char* second_key); + +static SkaStringHashMapNode* hash_map_create_node_string(SkaStringHashMap* hashMap, const char* key, const void* value, usize valueSize, SkaStringHashMapNode* next); +static void hash_map_destroy_node_string(SkaStringHashMapNode* node); + +static bool hash_map_push_front_string(SkaStringHashMap* hashMap, usize index, const char* key, const void* value, usize valueSize); +static void string_hash_map_grow_if_needed(SkaStringHashMap* hashMap); +static void string_hash_map_shrink_if_needed(SkaStringHashMap* hashMap); +static void string_hash_map_allocate(SkaStringHashMap* hashMap, usize capacity); +static void string_hash_map_rehash(SkaStringHashMap* hashMap, SkaStringHashMapNode** oldNode, usize oldCapacity); +static void string_hash_map_resize(SkaStringHashMap* hashMap, usize newCapacity); + +SkaStringHashMap* ska_string_hash_map_create(usize capacity) { + SkaStringHashMap* map = (SkaStringHashMap*)SKA_MEM_ALLOCATE(SkaStringHashMap); + map->capacity = capacity; + map->size = 0; + map->hashFunc = ska_default_hash_string; + map->compareFunc = ska_default_compare_string; + map->nodes = (SkaStringHashMapNode**) SKA_MEM_ALLOCATE_SIZE(capacity * sizeof(SkaStringHashMapNode*)); + memset(map->nodes, 0, capacity * sizeof(SkaStringHashMapNode*)); // TODO: fix + return map; +} + +SkaStringHashMap* ska_string_hash_map_create_default_capacity() { + return ska_string_hash_map_create(SKA_STRING_HASH_MAP_MIN_CAPACITY); +} + +SkaStringHashMapNode* hash_map_create_node_string(SkaStringHashMap* hashMap, const char* key, const void* value, usize valueSize, SkaStringHashMapNode* next) { + SkaStringHashMapNode* node = (SkaStringHashMapNode*) SKA_MEM_ALLOCATE_SIZE(sizeof(SkaStringHashMapNode)); + node->key = ska_strdup(key); + node->value = SKA_MEM_ALLOCATE_SIZE(valueSize); + memcpy(node->value, value, valueSize); + node->valueSize = valueSize; + node->next = next; + return node; +} + +bool ska_string_hash_map_destroy(SkaStringHashMap* hashMap) { + SkaStringHashMapNode* node = NULL; + SkaStringHashMapNode* next = NULL; + for (usize chain = 0; chain < hashMap->capacity; chain++) { + node = hashMap->nodes[chain]; + while (node) { + next = node->next; + hash_map_destroy_node_string(node); + node = next; + } + } + + SKA_MEM_FREE(hashMap); + + return true; +} + +bool hash_map_push_front_string(SkaStringHashMap* hashMap, usize index, const char* key, const void* value, usize valueSize) { + hashMap->nodes[index] = hash_map_create_node_string(hashMap, key, value, valueSize, hashMap->nodes[index]); + return hashMap->nodes[index] != NULL; +} + +bool ska_string_hash_map_add(SkaStringHashMap* hashMap, const char* key, const void* value, usize valueSize) { + SKA_ASSERT(hashMap != NULL); + SKA_ASSERT(key != NULL); + SKA_ASSERT(value != NULL); + + string_hash_map_grow_if_needed(hashMap); + + usize index = hashMap->hashFunc(key) % hashMap->capacity; + if (ska_string_hash_map_has(hashMap, key)) { + SkaStringHashMapNode* node = hashMap->nodes[index]; + memcpy(node->value, value, valueSize); + return true; // Updated Item + } + + if (!hash_map_push_front_string(hashMap, index, key, value, valueSize)) { + return false; // Error + } + + hashMap->size++; + // Inserted + return true; +} + +bool ska_string_hash_map_has(SkaStringHashMap* hashMap, const char* key) { + SKA_ASSERT(hashMap != NULL); + usize index = hashMap->hashFunc(key) % hashMap->capacity; + for (SkaStringHashMapNode* node = hashMap->nodes[index]; node; node = node->next) { + if (hashMap->compareFunc(key, node->key) == 0) { + return true; + } + } + return false; +} + +void* ska_string_hash_map_get(SkaStringHashMap* hashMap, const char* key) { + SKA_ASSERT_FMT(hashMap != NULL, "Trying to get key '%s' from a NULL hashmap!", key); + usize index = hashMap->hashFunc(key) % hashMap->capacity; + for (SkaStringHashMapNode* node = hashMap->nodes[index]; node; node = node->next) { + if (hashMap->compareFunc(key, node->key) == 0) { + return node->value; + } + } + return NULL; +} + +// TODO: Make better... +void* ska_string_hash_map_find(SkaStringHashMap* hashMap, const char* key) { + if (ska_string_hash_map_has(hashMap, key)) { + return ska_string_hash_map_get(hashMap, key); + } + return NULL; +} + +bool ska_string_hash_map_erase(SkaStringHashMap* hashMap, const char* key) { + SKA_ASSERT(hashMap != NULL); + SKA_ASSERT(key != NULL); + + usize index = hashMap->hashFunc(key) % hashMap->capacity; + SkaStringHashMapNode* node = hashMap->nodes[index]; + for (SkaStringHashMapNode* previous = NULL; node; previous = node, node = node->next) { + if (hashMap->compareFunc(key, node->key) == 0) { + if (previous != NULL) { + previous->next = node->next; + } else { + hashMap->nodes[index] = node->next; + } + + hash_map_destroy_node_string(node); + hashMap->size--; + + string_hash_map_shrink_if_needed(hashMap); + + return true; + } + } + + return false; +} + +void string_hash_map_grow_if_needed(SkaStringHashMap* hashMap) { + SKA_ASSERT_FMT(hashMap->size <= hashMap->capacity, "Hashmap size '%d' is bigger than its capacity '%d'!", hashMap->size, hashMap->capacity); + if (hashMap->size == hashMap->capacity) { + string_hash_map_resize(hashMap, hashMap->size * 2); + } +} + +void string_hash_map_shrink_if_needed(SkaStringHashMap* hashMap) { + SKA_ASSERT_FMT(hashMap->size <= hashMap->capacity, "Hashmap size '%d' is bigger than its capacity '%d'!", hashMap->size, hashMap->capacity); + usize shrinkCapacity = (usize) ((float) hashMap->capacity * SKA_STRING_HASH_MAP_SHRINK_THRESHOLD); + if (hashMap->size == shrinkCapacity) { + string_hash_map_resize(hashMap, shrinkCapacity); + } +} + +void string_hash_map_allocate(SkaStringHashMap* hashMap, usize capacity) { + hashMap->nodes = SKA_MEM_ALLOCATE_SIZE(capacity * sizeof(SkaStringHashMapNode*)); + memset(hashMap->nodes, 0, capacity * sizeof(SkaStringHashMapNode*)); + + hashMap->capacity = capacity; +} + +void string_hash_map_rehash(SkaStringHashMap* hashMap, SkaStringHashMapNode** oldNode, usize oldCapacity) { + for (usize chain = 0; chain < oldCapacity; chain++) { + for (SkaStringHashMapNode* node = oldNode[chain]; node != NULL;) { + SkaStringHashMapNode* next = node->next; + + usize newIndex = hashMap->hashFunc(node->key) % hashMap->capacity; + node->next = hashMap->nodes[newIndex]; + hashMap->nodes[newIndex] = node; + + node = next; + } + } +} + +void string_hash_map_resize(SkaStringHashMap* hashMap, usize newCapacity) { + if (newCapacity < SKA_STRING_HASH_MAP_MIN_CAPACITY) { + if (hashMap->capacity > SKA_STRING_HASH_MAP_MIN_CAPACITY) { + newCapacity = SKA_STRING_HASH_MAP_MIN_CAPACITY; + } else { + // Do nothing since the passed in capacity is too low and the current map's capacity is already at min limit + return; + } + } + + SkaStringHashMapNode** oldNode = hashMap->nodes; + usize oldCapacity = hashMap->capacity; + string_hash_map_allocate(hashMap, newCapacity); + + string_hash_map_rehash(hashMap, oldNode, oldCapacity); + + SKA_MEM_FREE(oldNode); +} + +// Int +bool ska_string_hash_map_add_int(SkaStringHashMap* hashMap, const char* key, int32 value) { + return ska_string_hash_map_add(hashMap, key, &value, sizeof(int32)); +} + +int32 ska_string_hash_map_get_int(SkaStringHashMap* hashMap, const char* key) { + return *(int32*) ska_string_hash_map_get(hashMap, key); +} + +// String +bool ska_string_hash_map_add_string(SkaStringHashMap* hashMap, const char* key, const char* value) { + char* stringVal = ska_strdup(value); + bool result = ska_string_hash_map_add(hashMap, key, stringVal, strlen(value) + 1); + SKA_MEM_FREE(stringVal); + return result; +} + +char* ska_string_hash_map_get_string(SkaStringHashMap* hashMap, const char* key) { + return (char*) ska_string_hash_map_get(hashMap, key); +} + +//--- Iterator ---// +SkaStringHashMapIterator ska_string_hash_map_iter_create(SkaStringHashMap* hashMap) { + // Get initial node if exists + SkaStringHashMapNode* initialNode = NULL; + usize initialIndex = 0; + for (usize chain = 0; chain < hashMap->capacity; chain++) { + SkaStringHashMapNode* node = hashMap->nodes[chain]; + if (node != NULL) { + initialNode = node; + initialIndex = chain + 1; + break; + } + } + usize iteratorCount = initialNode != NULL ? 1 : 0; + SkaStringHashMapIterator iterator = { .count = iteratorCount, .end = hashMap->capacity, .index = initialIndex, .pair = initialNode }; + return iterator; +} + +bool ska_string_hash_map_iter_is_valid(SkaStringHashMap* hashMap, SkaStringHashMapIterator* iterator) { + return iterator->pair != NULL && iterator->count <= hashMap->size; +} + +void ska_string_hash_map_iter_advance(SkaStringHashMap* hashMap, SkaStringHashMapIterator* iterator) { + if (ska_string_hash_map_iter_is_valid(hashMap, iterator)) { + if (iterator->pair->next != NULL) { + iterator->pair = iterator->pair->next; + iterator->count++; + return; + } + + // Search nodes array if there are no more linked pairs + for (usize chain = iterator->index; chain < hashMap->capacity; chain++) { + SkaStringHashMapNode* node = hashMap->nodes[chain]; + if (node != NULL) { + iterator->pair = node; + iterator->index = chain + 1; + iterator->count++; + return; + } + } + } + // Invalidate iterator since we've reached the end + iterator->pair = NULL; +} + +// Misc +usize ska_default_hash_string(const char* raw_key) { + // djb2 string hashing algorithm + // sstp://www.cse.yorku.ca/~oz/hash.ssml + usize byte; + usize hash = 5381; + usize key_size = strlen(raw_key); + + for (byte = 0; byte < key_size; ++byte) { + hash = ((hash << 5) + hash) ^ raw_key[byte]; + } + + return hash; +} + +int32 ska_default_compare_string(const char* first_key, const char* second_key) { + return strcmp(first_key, second_key); +} + +void hash_map_destroy_node_string(SkaStringHashMapNode* node) { + SKA_ASSERT(node != NULL); + SKA_ASSERT(node->value != NULL); + SKA_ASSERT(node->key != NULL); + SKA_MEM_FREE(node->key); + SKA_MEM_FREE(node->value); + SKA_MEM_FREE(node); +} diff --git a/seika1/data_structures/hash_map_string.h b/seika1/data_structures/hash_map_string.h new file mode 100644 index 0000000..658c336 --- /dev/null +++ b/seika1/data_structures/hash_map_string.h @@ -0,0 +1,63 @@ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "seika/defines.h" + +#define SKA_STRING_HASH_MAP_SHRINK_THRESHOLD 0.25f +#define SKA_STRING_HASH_MAP_MIN_CAPACITY 8 + +#define SKA_STRING_HASH_MAP_FOR_EACH(HASH_MAP, ITER_NAME) \ +for (SkaStringHashMapIterator ITER_NAME = ska_string_hash_map_iter_create(HASH_MAP); ska_string_hash_map_iter_is_valid(HASH_MAP, &(ITER_NAME)); ska_string_hash_map_iter_advance(HASH_MAP, &(ITER_NAME))) + +typedef usize (*SkaStringHashFunc) (const char*); +typedef int32 (*SkaStringCompareFunc) (const char*, const char*); + +typedef struct SkaStringHashMapNode { + struct SkaStringHashMapNode* next; + char* key; + void* value; + usize valueSize; +} SkaStringHashMapNode; + +typedef struct SkaStringHashMap { + usize capacity; + usize size; + SkaStringHashFunc hashFunc; + SkaStringCompareFunc compareFunc; + SkaStringHashMapNode** nodes; +} SkaStringHashMap; + +typedef struct SkaStringHashMapIterator { + usize count; + usize end; + usize index; + SkaStringHashMapNode* pair; +} SkaStringHashMapIterator; + +// Generic hash map methods +SkaStringHashMap* ska_string_hash_map_create(usize capacity); +SkaStringHashMap* ska_string_hash_map_create_default_capacity(); +bool ska_string_hash_map_destroy(SkaStringHashMap* hashMap); +bool ska_string_hash_map_add(SkaStringHashMap* hashMap, const char* key, const void* value, usize valueSize); +void* ska_string_hash_map_get(SkaStringHashMap* hashMap, const char* key); +void* ska_string_hash_map_find(SkaStringHashMap* hashMap, const char* key); +bool ska_string_hash_map_has(SkaStringHashMap* hashMap, const char* key); +bool ska_string_hash_map_erase(SkaStringHashMap* hashMap, const char* key); +// Int +bool ska_string_hash_map_add_int(SkaStringHashMap* hashMap, const char* key, int value); +int ska_string_hash_map_get_int(SkaStringHashMap* hashMap, const char* key); +// String +bool ska_string_hash_map_add_string(SkaStringHashMap* hashMap, const char* key, const char* value); +char* ska_string_hash_map_get_string(SkaStringHashMap* hashMap, const char* key); + +// Iterator +SkaStringHashMapIterator ska_string_hash_map_iter_create(SkaStringHashMap* hashMap); +bool ska_string_hash_map_iter_is_valid(SkaStringHashMap* hashMap, SkaStringHashMapIterator* iterator); +void ska_string_hash_map_iter_advance(SkaStringHashMap* hashMap, SkaStringHashMapIterator* iterator); + +#ifdef __cplusplus +} +#endif diff --git a/seika1/data_structures/queue.c b/seika1/data_structures/queue.c new file mode 100644 index 0000000..9bd2599 --- /dev/null +++ b/seika1/data_structures/queue.c @@ -0,0 +1,60 @@ +#include "queue.h" + +#include "seika/memory.h" + +SkaQueue* ska_queue_create(usize capacity, uint32 invalidValue) { + SkaQueue* queue = SKA_MEM_ALLOCATE(SkaQueue); + queue->capacity = capacity; + queue->invalidValue = invalidValue; + queue->size = 0; + queue->front = 0; + queue->rear = (uint32)capacity - 1; + queue->array = (uint32*)SKA_MEM_ALLOCATE_SIZE(queue->capacity * sizeof(uint32)); + return queue; +} + +void ska_queue_destroy(SkaQueue* queue) { + SKA_MEM_FREE(queue->array); + SKA_MEM_FREE(queue); +} + +bool ska_queue_is_full(SkaQueue* queue) { + return queue->size == queue->capacity; +} + +bool ska_queue_is_empty(SkaQueue* queue) { + return queue->size == 0; +} + +void ska_queue_enqueue(SkaQueue* queue, uint32 item) { + if (ska_queue_is_full(queue)) { + return; + } + queue->rear = (queue->rear + 1) % queue->capacity; + queue->array[queue->rear] = item; + queue->size++; +} + +uint32 ska_queue_dequeue(SkaQueue* queue) { + if (ska_queue_is_empty(queue)) { + return queue->invalidValue; + } + uint32 value = queue->array[queue->front]; + queue->front = (queue->front + 1) % queue->capacity; + queue->size--; + return value; +} + +uint32 ska_queue_front(SkaQueue* queue) { + if (ska_queue_is_empty(queue)) { + return queue->invalidValue; + } + return queue->array[queue->front]; +} + +uint32 ska_queue_rear(SkaQueue* queue) { + if (ska_queue_is_empty(queue)) { + return queue->invalidValue; + } + return queue->array[queue->rear]; +} diff --git a/seika1/data_structures/queue.h b/seika1/data_structures/queue.h new file mode 100644 index 0000000..9749be5 --- /dev/null +++ b/seika1/data_structures/queue.h @@ -0,0 +1,21 @@ +#pragma once + +#include "seika/defines.h" + +// TODO: If other types are needed, create a macro to simplify queues by type + +// Unsigned int queue +typedef struct SkaQueue { + uint32 front, rear, size, invalidValue; + usize capacity; + uint32* array; +} SkaQueue; + +SkaQueue* ska_queue_create(usize capacity, uint32 invalidValue); +void ska_queue_destroy(SkaQueue* queue); +bool ska_queue_is_full(SkaQueue* queue); +bool ska_queue_is_empty(SkaQueue* queue); +void ska_queue_enqueue(SkaQueue* queue, uint32 item); +uint32 ska_queue_dequeue(SkaQueue* queue); +uint32 ska_queue_front(SkaQueue* queue); +uint32 ska_queue_rear(SkaQueue* queue); diff --git a/seika1/data_structures/spatial_hash_map.c b/seika1/data_structures/spatial_hash_map.c new file mode 100644 index 0000000..b66a822 --- /dev/null +++ b/seika1/data_structures/spatial_hash_map.c @@ -0,0 +1,264 @@ +#include "spatial_hash_map.h" + +#include +#include + +#include "seika/memory.h" +#include "seika/assert.h" + +#define SKA_SPATIAL_HASH_NULL_ENTITY 4294967295 +#define SKA_SPATIAL_HASH_MAX_POSITION_HASH 8 + +typedef struct PositionHashes { + usize hashCount; + int32 hashes[SKA_SPATIAL_HASH_MAX_POSITION_HASH]; +} PositionHashes; + +static void spatial_hash_map_update(SkaSpatialHashMap* hashMap, uint32 entity, SkaSpatialHashMapGridSpacesHandle* handle, SkaRect2* collisionRect); +static bool change_cell_size_if_needed(SkaSpatialHashMap* hashMap, SkaRect2* collisionRectToCheck); +static int32 spatial_hash(SkaSpatialHashMap* hashMap, SkaVector2* position); +static SkaSpatialHashMapGridSpace* get_or_create_grid_space(SkaSpatialHashMap* hashMap, int32 positionHash); +static bool link_object_by_position_hash(SkaSpatialHashMap* hashMap, SkaSpatialHashMapGridSpacesHandle* object, uint32 value, int32 positionHash, PositionHashes* hashes); +static bool unlink_object_by_entity(SkaSpatialHashMap* hashMap, SkaSpatialHashMapGridSpacesHandle* object, SkaSpatialHashMapGridSpace* gridSpace, uint32 entity); +static void unlink_all_objects_by_entity(SkaSpatialHashMap* hashMap, SkaSpatialHashMapGridSpacesHandle* object, uint32 entity); +static bool collision_result_has_entity(SkaSpatialHashMapCollisionResult* result, uint32 entity); + +// Public facing functions +SkaSpatialHashMap* ska_spatial_hash_map_create(int32 initialCellSize) { + SkaSpatialHashMap* map = SKA_MEM_ALLOCATE(SkaSpatialHashMap); + map->cellSize = initialCellSize; + map->largestObjectSize = initialCellSize; + map->gridMap = ska_hash_map_create(sizeof(int32), sizeof(SkaSpatialHashMapGridSpace **), SKA_HASH_MAP_MIN_CAPACITY); + map->objectToGridMap = ska_hash_map_create(sizeof(uint32), sizeof(SkaSpatialHashMapGridSpacesHandle **), + SKA_HASH_MAP_MIN_CAPACITY); + map->doesCollisionDataNeedUpdating = false; + return map; +} + +void ska_spatial_hash_map_destroy(SkaSpatialHashMap* hashMap) { + // Grid map + SKA_HASH_MAP_FOR_EACH(hashMap->gridMap, iter) { + SkaHashMapNode* node = iter.pair; + SkaSpatialHashMapGridSpace* gridSpace = (SkaSpatialHashMapGridSpace*) *(SkaSpatialHashMapGridSpace**) node->value; + SKA_MEM_FREE(gridSpace); + } + ska_hash_map_destroy(hashMap->gridMap); + // Grid space Handle Map + SKA_HASH_MAP_FOR_EACH(hashMap->objectToGridMap, iter) { + SkaHashMapNode* node = iter.pair; + SkaSpatialHashMapGridSpacesHandle* handle = (SkaSpatialHashMapGridSpacesHandle*) *(SkaSpatialHashMapGridSpacesHandle**) node->value; + SKA_MEM_FREE(handle); + } + ska_hash_map_destroy(hashMap->objectToGridMap); + // Finally free the hashmap memory + SKA_MEM_FREE(hashMap); +} + +// The purpose of this function is to make sure that 'cellSize' is twice as big as the largest object +bool change_cell_size_if_needed(SkaSpatialHashMap* hashMap, SkaRect2* collisionRectToCheck) { + const int32 objectMaxSize = collisionRectToCheck->h > collisionRectToCheck->w ? (int32)collisionRectToCheck->h : (int32)collisionRectToCheck->w; + // Update largest object size of hashmap if applicable + if (objectMaxSize > hashMap->largestObjectSize) { + hashMap->largestObjectSize = objectMaxSize; + } + // Check if cell size needs to grow or shrink + if (objectMaxSize > hashMap->cellSize * 2 || hashMap->largestObjectSize < hashMap->cellSize / 8) { + hashMap->cellSize = objectMaxSize * 2; + return true; + } + + return false; +} + +SkaSpatialHashMapGridSpacesHandle* ska_spatial_hash_map_insert_or_update(SkaSpatialHashMap* hashMap, uint32 entity, SkaRect2* collisionRect) { + // Create new object handle if it doesn't exist + if (!ska_hash_map_has(hashMap->objectToGridMap, &entity)) { + SkaSpatialHashMapGridSpacesHandle* newHandle = SKA_MEM_ALLOCATE(SkaSpatialHashMapGridSpacesHandle); + newHandle->gridSpaceCount = 0; + newHandle->collisionRect = (SkaRect2) { + 0.0f, 0.0f, 0.0f, 0.0f + }; + ska_hash_map_add(hashMap->objectToGridMap, &entity, &newHandle); + } + + // Update cell size and rebuild map if an object is bigger than the cell size + if (change_cell_size_if_needed(hashMap, collisionRect)) { + // Since we have changed cell size and largest object size, rebuild spatial hash + SKA_HASH_MAP_FOR_EACH(hashMap->objectToGridMap, iter) { + const uint32 updatedEntity = *(uint32*) iter.pair->key; + if (entity != updatedEntity) { + SkaSpatialHashMapGridSpacesHandle* updatedHandle = (SkaSpatialHashMapGridSpacesHandle*) iter.pair->value; + spatial_hash_map_update(hashMap, updatedEntity, updatedHandle, &updatedHandle->collisionRect); + } + } + } + + SkaSpatialHashMapGridSpacesHandle* objectHandle = (SkaSpatialHashMapGridSpacesHandle*) *(SkaSpatialHashMapGridSpacesHandle**) ska_hash_map_get( + hashMap->objectToGridMap, &entity); + spatial_hash_map_update(hashMap, entity, objectHandle, collisionRect); + return objectHandle; +} + +void spatial_hash_map_update(SkaSpatialHashMap* hashMap, uint32 entity, SkaSpatialHashMapGridSpacesHandle* handle, SkaRect2* collisionRect) { + memcpy(&handle->collisionRect, collisionRect, sizeof(SkaRect2)); + + // Unlink all previous spaces and objects + unlink_all_objects_by_entity(hashMap, handle, entity); + + // Add values to spaces and spaces to object handles (moving clockwise starting from top-left) + PositionHashes hashes = { .hashCount = 0 }; + // Top left + const int32 topLeftHash = spatial_hash(hashMap, &(SkaVector2) { + collisionRect->x, collisionRect->y + }); + link_object_by_position_hash(hashMap, handle, entity, topLeftHash, &hashes); + // Top right + const int32 topRightHash = spatial_hash(hashMap, &(SkaVector2) { + collisionRect->x + collisionRect->w, collisionRect->y + }); + link_object_by_position_hash(hashMap, handle, entity, topRightHash, &hashes); + // Bottom Left + const int32 bottomLeftHash = spatial_hash(hashMap, &(SkaVector2) { + collisionRect->x, collisionRect->y + collisionRect->h + }); + link_object_by_position_hash(hashMap, handle, entity, bottomLeftHash, &hashes); + // Bottom Right + const int32 bottomRightHash = spatial_hash(hashMap, &(SkaVector2) { + collisionRect->x + collisionRect->w, collisionRect->y + collisionRect->h + }); + link_object_by_position_hash(hashMap, handle, entity, bottomRightHash, &hashes); +} + +void ska_spatial_hash_map_remove(SkaSpatialHashMap* hashMap, uint32 entity) { + if (!ska_hash_map_has(hashMap->objectToGridMap, &entity)) { + return; + } + SkaSpatialHashMapGridSpacesHandle* objectHandle = (SkaSpatialHashMapGridSpacesHandle*) *(SkaSpatialHashMapGridSpacesHandle**) ska_hash_map_get( + hashMap->objectToGridMap, &entity); + unlink_all_objects_by_entity(hashMap, objectHandle, entity); + ska_hash_map_erase(hashMap->objectToGridMap, &entity); + // TODO: Use something more efficient than looping through the entire hashmap to find the largest object size + const int32 MaxObjectSize = objectHandle->collisionRect.h > objectHandle->collisionRect.w ? (int32)objectHandle->collisionRect.h : (int32)objectHandle->collisionRect.w; + if (MaxObjectSize == hashMap->largestObjectSize) { + int32 foundLargestObjectSize = -1; + SKA_HASH_MAP_FOR_EACH(hashMap->objectToGridMap, iter) { + SkaSpatialHashMapGridSpacesHandle* nodeObjectHandle = (SkaSpatialHashMapGridSpacesHandle*) iter.pair->value; + const int32 nodeMaxObjectSize = nodeObjectHandle->collisionRect.h > nodeObjectHandle->collisionRect.w ? (int32)nodeObjectHandle->collisionRect.h : (int32)nodeObjectHandle->collisionRect.w; + // Early out if we find another object with the same size + if (nodeMaxObjectSize == hashMap->largestObjectSize) { + foundLargestObjectSize = -1; + break; + } else if(nodeMaxObjectSize > foundLargestObjectSize) { + foundLargestObjectSize = nodeMaxObjectSize; + } + } + if (foundLargestObjectSize > 0) { + hashMap->largestObjectSize = foundLargestObjectSize; + } + } + SKA_MEM_FREE(objectHandle); +} + +SkaSpatialHashMapGridSpacesHandle* ska_spatial_hash_map_get(SkaSpatialHashMap* hashMap, uint32 entity) { + if (ska_hash_map_has(hashMap->objectToGridMap, &entity)) { + return (SkaSpatialHashMapGridSpacesHandle*) *(SkaSpatialHashMapGridSpacesHandle**) ska_hash_map_get( + hashMap->objectToGridMap, &entity); + } + return NULL; +} + +SkaSpatialHashMapCollisionResult ska_spatial_hash_map_compute_collision(SkaSpatialHashMap* hashMap, uint32 entity) { + SkaSpatialHashMapCollisionResult result = { .collisionCount = 0 }; + void* objectHandlePtr = ska_hash_map_get(hashMap->objectToGridMap, &entity); + // Early out if object not in spatial hash map + if (objectHandlePtr == NULL) { + return result; + } + SkaSpatialHashMapGridSpacesHandle* objectHandle = (SkaSpatialHashMapGridSpacesHandle*) *(SkaSpatialHashMapGridSpacesHandle**) objectHandlePtr; + for (usize i = 0; i < objectHandle->gridSpaceCount; i++) { + SkaSpatialHashMapGridSpace* gridSpace = objectHandle->gridSpaces[i]; + for (usize j = 0; j < gridSpace->entityCount; j++) { + uint32 entityToCollide = gridSpace->entities[j]; + if (entity != entityToCollide && !collision_result_has_entity(&result, entityToCollide)) { + SkaSpatialHashMapGridSpacesHandle* entityToCollideObjectHandle = (SkaSpatialHashMapGridSpacesHandle*) *(SkaSpatialHashMapGridSpacesHandle**) ska_hash_map_get( + hashMap->objectToGridMap, &entityToCollide); + // Now that we have passed all checks, actually check collision + if (se_rect2_does_rectangles_overlap(&objectHandle->collisionRect, &entityToCollideObjectHandle->collisionRect)) { + SKA_ASSERT_FMT(result.collisionCount + 1 <= SKA_SPATIAL_HASH_GRID_MAX_COLLISIONS, "At limit of collisions '%d', consider increasing 'SE_SPATIAL_HASH_GRID_MAX_COLLISIONS'", SKA_SPATIAL_HASH_GRID_MAX_COLLISIONS); + result.collisions[result.collisionCount++] = entityToCollide; + } + } + } + } + return result; +} + +// Internal Functions +int32 spatial_hash(SkaSpatialHashMap* hashMap, SkaVector2* position) { + const int32 x = (int32) position->x / hashMap->cellSize; + const int32 y = (int32) position->y / hashMap->cellSize; + const int32 hash = ((x * x) ^ (y * y)) % INT32_MAX; + return hash; +} + +SkaSpatialHashMapGridSpace* get_or_create_grid_space(SkaSpatialHashMap* hashMap, int32 positionHash) { + if (!ska_hash_map_has(hashMap->gridMap, &positionHash)) { + SkaSpatialHashMapGridSpace* newGridSpace = SKA_MEM_ALLOCATE(SkaSpatialHashMapGridSpace); + newGridSpace->entityCount = 0; + ska_hash_map_add(hashMap->gridMap, &positionHash, &newGridSpace); + } + SkaSpatialHashMapGridSpace* gridSpace = (SkaSpatialHashMapGridSpace*) *(SkaSpatialHashMapGridSpace**) ska_hash_map_get( + hashMap->gridMap, &positionHash); + return gridSpace; +} + +bool link_object_by_position_hash(SkaSpatialHashMap* hashMap, SkaSpatialHashMapGridSpacesHandle* object, uint32 value, int32 positionHash, PositionHashes* hashes) { + // Exit if position hash exists + for (usize i = 0; i < hashes->hashCount; i++) { + if (positionHash == hashes->hashes[i]) { + return false; + } + } + // Link + SkaSpatialHashMapGridSpace* gridSpace = get_or_create_grid_space(hashMap, positionHash); + gridSpace->entities[gridSpace->entityCount++] = value; + object->gridSpaces[object->gridSpaceCount++] = gridSpace; + SKA_ASSERT_FMT(hashes->hashCount + 1 < SKA_SPATIAL_HASH_MAX_POSITION_HASH, + "Current hash count for value '%d' exceeds 'SE_SPATIAL_HASH_MAX_POSITION_HASH (%d)', consider increasing SE_SPATIAL_HASH_MAX_POSITION_HASH!"); + hashes->hashes[hashes->hashCount++] = positionHash; + return true; +} + +bool unlink_object_by_entity(SkaSpatialHashMap* hashMap, SkaSpatialHashMapGridSpacesHandle* object, SkaSpatialHashMapGridSpace* gridSpace, uint32 entity) { + bool objectUnlinked = false; + for (usize i = 0; i < gridSpace->entityCount; i++) { + if (entity == gridSpace->entities[i] || gridSpace->entities[i] == SKA_SPATIAL_HASH_NULL_ENTITY) { + if (i + 1 < gridSpace->entityCount) { + gridSpace->entities[i] = gridSpace->entities[i + 1]; + gridSpace->entities[i + 1] = SKA_SPATIAL_HASH_NULL_ENTITY; + } + objectUnlinked = true; + } + } + if (objectUnlinked) { + object->gridSpaceCount--; + gridSpace->entityCount--; + } + return objectUnlinked; +} + +void unlink_all_objects_by_entity(SkaSpatialHashMap* hashMap, SkaSpatialHashMapGridSpacesHandle* object, uint32 entity) { + const usize numberOfSpaces = object->gridSpaceCount; + for (usize i = 0; i < numberOfSpaces; i++) { + unlink_object_by_entity(hashMap, object, object->gridSpaces[i], entity); + } +} + +bool collision_result_has_entity(SkaSpatialHashMapCollisionResult* result, uint32 entity) { + for (usize i = 0; i < result->collisionCount; i++) { + if (entity == result->collisions[i]) { + return true; + } + } + return false; +} diff --git a/seika1/data_structures/spatial_hash_map.h b/seika1/data_structures/spatial_hash_map.h new file mode 100644 index 0000000..37acb34 --- /dev/null +++ b/seika1/data_structures/spatial_hash_map.h @@ -0,0 +1,43 @@ +#pragma once + +#include "seika/math/math.h" +#include "seika/data_structures/hash_map.h" + +#define SKA_SPATIAL_HASH_GRID_SPACE_ENTITY_LIMIT 32 +#define SKA_SPATIAL_HASH_GRID_MAX_COLLISIONS 16 + +// Note: Spatial hash expects rectangles that have 0 rotation + +// Contains the object id for a particular grid space +typedef struct SkaSpatialHashMapGridSpace { + unsigned int entities[SKA_SPATIAL_HASH_GRID_SPACE_ENTITY_LIMIT]; + usize entityCount; +} SkaSpatialHashMapGridSpace; + +// Contains all grid spaces an object is assigned to +typedef struct SkaSpatialHashMapGridSpacesHandle { + usize gridSpaceCount; + SkaRect2 collisionRect; + SkaSpatialHashMapGridSpace* gridSpaces[4]; +} SkaSpatialHashMapGridSpacesHandle; + +// Contains a hash map of buckets that correspond to a space on a grid +typedef struct SkaSpatialHashMap { + int cellSize; // Cell size should be 2x the size of the largest object + int largestObjectSize; // Used to keep track of the largest object size. If size is 8x less than cell size, we should resize spatial hash. + SkaHashMap* gridMap; // Contains objects within a grid. + SkaHashMap* objectToGridMap; // Contains contains all grid spaces an object is assigned to. + bool doesCollisionDataNeedUpdating; +} SkaSpatialHashMap; + +typedef struct SkaSpatialHashMapCollisionResult { + usize collisionCount; + unsigned int collisions[SKA_SPATIAL_HASH_GRID_MAX_COLLISIONS]; +} SkaSpatialHashMapCollisionResult; + +SkaSpatialHashMap* ska_spatial_hash_map_create(int32 initialCellSize); +void ska_spatial_hash_map_destroy(SkaSpatialHashMap* hashMap); +SkaSpatialHashMapGridSpacesHandle* ska_spatial_hash_map_insert_or_update(SkaSpatialHashMap* hashMap, uint32 entity, SkaRect2* collisionRect); +void ska_spatial_hash_map_remove(SkaSpatialHashMap* hashMap, uint32 entity); +SkaSpatialHashMapGridSpacesHandle* ska_spatial_hash_map_get(SkaSpatialHashMap* hashMap, uint32 entity); +SkaSpatialHashMapCollisionResult ska_spatial_hash_map_compute_collision(SkaSpatialHashMap* hashMap, uint32 entity); diff --git a/seika1/data_structures/static_array.h b/seika1/data_structures/static_array.h new file mode 100644 index 0000000..05caa9a --- /dev/null +++ b/seika1/data_structures/static_array.h @@ -0,0 +1,107 @@ +#pragma once + +#include "seika/defines.h" +#include "seika/data_structures/array_utils.h" + +// Helper class for generalized use of static arrays + +#define SKA_STATIC_ARRAY_CREATE(ARRAY_TYPE, ARRAY_SIZE, ARRAY_NAME) \ +static ARRAY_TYPE ARRAY_NAME[ARRAY_SIZE]; \ +static usize ARRAY_NAME ##_count = 0 + +#define SKA_STATIC_ARRAY_FOR_LOOP(ARRAY_NAME) \ +for (usize ARRAY_NAME ##_loop_index = 0; ARRAY_NAME ##_loop_index < ARRAY_NAME ##_count; ARRAY_NAME ##_loop_index++) + +#define SKA_STATIC_ARRAY_ADD(ARRAY_NAME, ARRAY_VALUE) \ +ARRAY_NAME[ARRAY_NAME ##_count++] = ARRAY_VALUE + +#define SKA_STATIC_ARRAY_ADD_IF_UNIQUE(ARRAY_NAME, ARRAY_VALUE) \ +{ \ +bool ARRAY_NAME ##_has_duplicate = false; \ +for (usize ARRAY_NAME ##_loop_index = 0; ARRAY_NAME ##_loop_index < ARRAY_NAME ##_count; ARRAY_NAME ##_loop_index++) { \ +if (ARRAY_NAME[ARRAY_NAME ##_loop_index] == ARRAY_VALUE) { \ +ARRAY_NAME ##_has_duplicate = true; \ +break; \ +}\ +} \ +if (!ARRAY_NAME ##_has_duplicate) { \ +SKA_STATIC_ARRAY_ADD(ARRAY_NAME, ARRAY_VALUE); \ +} \ +} + +#define SKA_STATIC_ARRAY_REMOVE(ARRAY_NAME, ARRAY_VALUE, EMPTY_VALUE) \ +{ \ +const usize ARRAY_NAME ##_count_ref = ARRAY_NAME ##_count; \ +for (usize ARRAY_NAME ##_loop_index = 0; ARRAY_NAME ##_loop_index < ARRAY_NAME ##_count_ref; ARRAY_NAME ##_loop_index++) { \ +if (ARRAY_NAME[ARRAY_NAME ##_loop_index] == ARRAY_VALUE) { \ +ARRAY_NAME[ARRAY_NAME ##_loop_index] = ARRAY_NAME[ARRAY_NAME ##_loop_index + 1]; \ +ARRAY_NAME[ARRAY_NAME ##_loop_index + 1] = EMPTY_VALUE; \ +ARRAY_NAME ##_count--; \ +} \ +if (ARRAY_NAME[ARRAY_NAME ##_loop_index] == EMPTY_VALUE && ARRAY_NAME ##_loop_index + 1 < ARRAY_NAME ##_count_ref) { \ +ARRAY_NAME[ARRAY_NAME ##_loop_index] = ARRAY_NAME[ARRAY_NAME ##_loop_index + 1]; \ +ARRAY_NAME[ARRAY_NAME ##_loop_index + 1] = EMPTY_VALUE; \ +} \ +} \ +} + +#define SKA_STATIC_ARRAY_REMOVE_WITH_PREDICATE(ARRAY_NAME, ARRAY_VALUE, EMPTY_VALUE, ARRAY_TYPE, PRED_FUNC) \ +{ \ +bool (*static_array_compare_func)(ARRAY_TYPE first, ARRAY_TYPE second) = PRED_FUNC; \ +const usize ARRAY_NAME ##_count_ref = ARRAY_NAME ##_count; \ +for (usize ARRAY_NAME ##_loop_index = 0; ARRAY_NAME ##_loop_index < ARRAY_NAME ##_count_ref; ARRAY_NAME ##_loop_index++) { \ +if (static_array_compare_func(ARRAY_NAME[ARRAY_NAME ##_loop_index], ARRAY_VALUE)) { \ +ARRAY_NAME[ARRAY_NAME ##_loop_index] = ARRAY_NAME[ARRAY_NAME ##_loop_index + 1]; \ +ARRAY_NAME[ARRAY_NAME ##_loop_index + 1] = EMPTY_VALUE; \ +ARRAY_NAME ##_count--; \ +} \ +if (ARRAY_NAME[ARRAY_NAME ##_loop_index] == EMPTY_VALUE && ARRAY_NAME ##_loop_index + 1 < ARRAY_NAME ##_count_ref) { \ +ARRAY_NAME[ARRAY_NAME ##_loop_index] = ARRAY_NAME[ARRAY_NAME ##_loop_index + 1]; \ +ARRAY_NAME[ARRAY_NAME ##_loop_index + 1] = EMPTY_VALUE; \ +} \ +} \ +} + +#define SKA_STATIC_ARRAY_EMPTY(ARRAY_NAME) \ +ARRAY_NAME ##_count = 0; + +#define SKA_STATIC_ARRAY_SIZE(ARRAY_NAME) (ARRAY_NAME ##_count) + +#define SKA_STATIC_ARRAY_SORT_INT(ARRAY_NAME) \ +if (SKA_STATIC_ARRAY_SIZE(ARRAY_NAME) > 0) { \ +ska_array_utils_selection_sort_int(ARRAY_NAME, (int32)SKA_STATIC_ARRAY_SIZE(ARRAY_NAME)); \ +} + +// Array Utils (TODO: Move in own file) +#define SKA_ARRAY_REMOVE_AND_CONDENSE(ARRAY_NAME, ARRAY_SIZE_VAR, ARRAY_VALUE, EMPTY_VALUE) \ +{ \ +const usize temp_arac_size = ARRAY_SIZE_VAR; \ +for (usize temp_arac_loop_index = 0; temp_arac_loop_index < temp_arac_size; temp_arac_loop_index++) { \ +if (ARRAY_NAME[temp_arac_loop_index] == ARRAY_VALUE) { \ +ARRAY_NAME[temp_arac_loop_index] = ARRAY_NAME[temp_arac_loop_index + 1]; \ +ARRAY_NAME[temp_arac_loop_index + 1] = EMPTY_VALUE; \ +ARRAY_SIZE_VAR--; \ +} \ +if (ARRAY_NAME[temp_arac_loop_index] == EMPTY_VALUE && temp_arac_loop_index + 1 < temp_arac_size) { \ +ARRAY_NAME[temp_arac_loop_index] = ARRAY_NAME[temp_arac_loop_index + 1]; \ +ARRAY_NAME[temp_arac_loop_index + 1] = EMPTY_VALUE; \ +} \ +} \ +} + +#define SKA_ARRAY_REMOVE_AND_CONDENSE_PREDICATE(ARRAY_NAME, ARRAY_SIZE_VAR, ARRAY_VALUE, EMPTY_VALUE, ARRAY_TYPE, PRED_FUNC) \ +{ \ +bool (*static_array_compare_func)(ARRAY_TYPE first, ARRAY_TYPE second) = PRED_FUNC; \ +const usize temp_arac_size = ARRAY_SIZE_VAR; \ +for (usize temp_arac_loop_index = 0; temp_arac_loop_index < temp_arac_size; temp_arac_loop_index++) { \ +if (static_array_compare_func(ARRAY_NAME[temp_arac_loop_index], ARRAY_VALUE)) { \ +ARRAY_NAME[temp_arac_loop_index] = ARRAY_NAME[temp_arac_loop_index + 1]; \ +ARRAY_NAME[temp_arac_loop_index + 1] = EMPTY_VALUE; \ +ARRAY_SIZE_VAR--; \ +} \ +if (ARRAY_NAME[temp_arac_loop_index] == EMPTY_VALUE && temp_arac_loop_index + 1 < temp_arac_size) { \ +ARRAY_NAME[temp_arac_loop_index] = ARRAY_NAME[temp_arac_loop_index + 1]; \ +ARRAY_NAME[temp_arac_loop_index + 1] = EMPTY_VALUE; \ +} \ +} \ +} diff --git a/seika1/math/curve_float.c b/seika1/math/curve_float.c new file mode 100644 index 0000000..d5197fb --- /dev/null +++ b/seika1/math/curve_float.c @@ -0,0 +1,93 @@ +#include "curve_float.h" + +#include "seika/math/math.h" +#include "seika/assert.h" + +// Helper functions +void control_point_swap(SkaCurveControlPoint* pointA, SkaCurveControlPoint* pointB) { + SkaCurveControlPoint temp = *pointA; + *pointA = *pointB; + *pointB = temp; +} + +// Function to perform Selection Sort +void selection_sort_curve_float(SkaCurveFloat* curve) { + usize minX; + // One by one move boundary of unsorted subarray + for (usize i = 0; i < curve->controlPointCount - 1; i++) { + // Find the minimum element in unsorted array + minX = i; + for (usize j = i + 1; j < curve->controlPointCount; j++) { + if (curve->controlPoints[j].x < curve->controlPoints[minX].x) { + minX = j; + } + } + // Swap the found minimum element + // with the first element + control_point_swap(&curve->controlPoints[minX], &curve->controlPoints[i]); + } +} + +//--- SkaCurveFloat ---// +void ska_curve_float_add_control_point(SkaCurveFloat* curve, SkaCurveControlPoint point) { + SKA_ASSERT_FMT(curve->controlPointCount + 1 < SKA_CURVE_MAX_CONTROL_POINTS, "Trying to add more points than max '%u'", SKA_CURVE_MAX_CONTROL_POINTS); + curve->controlPoints[curve->controlPointCount++] = point; + selection_sort_curve_float(curve); +} + +void ska_curve_float_add_control_points(SkaCurveFloat* curve, SkaCurveControlPoint points[], usize count) { + if (count == 0) { + return; + } + for (usize i = 0; i < count; i++) { + SKA_ASSERT_FMT(curve->controlPointCount + 1 < SKA_CURVE_MAX_CONTROL_POINTS, "Trying to add multiple points that go beyond the max of '%u'", SKA_CURVE_MAX_CONTROL_POINTS); + curve->controlPoints[curve->controlPointCount++] = points[i]; + } + selection_sort_curve_float(curve); +} + +bool ska_curve_float_remove_control_point(SkaCurveFloat* curve, f64 x, f64 y) { + for (usize i = 0; i < curve->controlPointCount; i++) { + SkaCurveControlPoint* point = &curve->controlPoints[i]; + if (ska_math_is_almost_equal_double_default(x, point->x) && ska_math_is_almost_equal_double_default(y, point->y)) { + // We've found a matching point so set it's x to the highest value, sort it, then decrement the point count. + point->x = DBL_MAX; + selection_sort_curve_float(curve); + curve->controlPointCount--; + return true; + } + } + return false; +} + +f64 ska_curve_float_eval(const SkaCurveFloat* curve, f64 t) { + if (curve->controlPointCount == 0) { + return 0.0; + } else if (curve->controlPointCount == 1) { + return curve->controlPoints[0].y; + } + usize leftIndex = 0; + usize rightIndex = curve->controlPointCount - 1; + while (rightIndex - leftIndex > 1) { + usize midIndex = (leftIndex + rightIndex) / 2; + if (t < curve->controlPoints[midIndex].x) { + rightIndex = midIndex; + } else { + leftIndex = midIndex; + } + } + + const SkaCurveControlPoint* leftPoint = &curve->controlPoints[leftIndex]; + const SkaCurveControlPoint* rightPoint = &curve->controlPoints[rightIndex]; + + const f64 t1 = (t - leftPoint->x) / (rightPoint->x - leftPoint->x); + const f64 t2 = t1 * t1; + const f64 t3 = t2 * t1; + + const f64 a = 2.0f * t3 - 3.0f * t2 + 1.0f; + const f64 b = -2.0f * t3 + 3.0f * t2; + const f64 c = t3 - 2.0f * t2 + t1; + const f64 d = t3 - t2; + + return a * leftPoint->y + b * rightPoint->y + c * leftPoint->tangentOut + d * rightPoint->tangentIn; +} diff --git a/seika1/math/curve_float.h b/seika1/math/curve_float.h new file mode 100644 index 0000000..16ed517 --- /dev/null +++ b/seika1/math/curve_float.h @@ -0,0 +1,33 @@ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +#include "seika/defines.h" + +#define SKA_CURVE_MAX_CONTROL_POINTS 16 + +typedef struct SkaCurveControlPoint { + f64 x; // a.k.a time + f64 y; // a.k.a value + f64 tangentIn; + f64 tangentOut; +} SkaCurveControlPoint; + +typedef struct SkaCurveFloat { + usize controlPointCount; + SkaCurveControlPoint controlPoints[SKA_CURVE_MAX_CONTROL_POINTS]; +} SkaCurveFloat; + +void ska_curve_float_add_control_point(SkaCurveFloat* curve, SkaCurveControlPoint point); +void ska_curve_float_add_control_points(SkaCurveFloat* curve, SkaCurveControlPoint points[], usize count); +bool ska_curve_float_remove_control_point(SkaCurveFloat* curve, f64 x, f64 y); +f64 ska_curve_float_eval(const SkaCurveFloat* curve, f64 t); + +#ifdef __cplusplus +} +#endif diff --git a/seika1/math/math.c b/seika1/math/math.c new file mode 100644 index 0000000..92f2923 --- /dev/null +++ b/seika1/math/math.c @@ -0,0 +1,176 @@ +#include "math.h" + +// --- Vector2 --- // +bool ska_math_vec2_equals(const SkaVector2* v1, const SkaVector2* v2) { + return v1->x == v2->x && v1->y == v2->y; +} + +SkaVector2 ska_math_vec2_lerp(const SkaVector2* v1, const SkaVector2* v2, f32 alpha) { + return (SkaVector2) { + .x = ska_math_lerpf(v1->x, v2->x, alpha), + .y = ska_math_lerpf(v1->y, v2->y, alpha) + }; +} + +f32 ska_math_vec2_angle(const SkaVector2* v) { + f32 angle = atan2f(v->y, v->x); + if (angle < 0.0f) { + angle += 2.0f * SKA_PI; + } + return angle; +} + +// --- Rect2 --- // +bool se_rect2_does_rectangles_overlap(const SkaRect2* sourceRect, const SkaRect2* targetRect) { + return (sourceRect->x + sourceRect->w >= targetRect->x) && + (targetRect->x + targetRect->w >= sourceRect->x) && + (sourceRect->y + sourceRect->h >= targetRect->y) && + (targetRect->y + targetRect->h >= sourceRect->y); +} + +// --- Transform2D --- // +void ska_transform2d_mat4_to_transform(mat4 matrix, SkaTransform2D* transform) { + // Decompose trs matrix + vec4 translation; + mat4 rotation; + vec3 scale; + glm_decompose(matrix, translation, rotation, scale); + // Update position + transform->position = (SkaVector2){ .x = translation[0], .y = translation[1] }; + // Update scale + transform->scale = (SkaVector2){ .x = fabsf(scale[0]), .y = fabsf(scale[1]) }; + // Convert rotation to degrees + versor quat; + glm_mat4_quat(rotation, quat); + const f32 angleRadians = glm_quat_angle(quat); + transform->rotation = glm_deg(angleRadians); +} + +void ska_transform2d_transform_to_mat4(const SkaTransform2D* transform, mat4 matrix) { + // Create translation matrix + glm_translate_make(matrix, (vec3){transform->position.x, transform->position.y, 0.0f}); + // Create rotation matrix (convert degrees to radians) + glm_rotate_z(matrix, glm_rad(transform->rotation), matrix); + // Create scale matrix + glm_scale(matrix, (vec3){transform->scale.x, transform->scale.y, 1.0f}); +} + +SkaTransform2D ska_transform2d_lerp(const SkaTransform2D* tA, const SkaTransform2D* tB, f32 alpha) { + return (SkaTransform2D) { + .position = ska_math_vec2_lerp(&tA->position, &tB->position, alpha), + .scale = ska_math_vec2_lerp(&tA->scale, &tB->scale, alpha), + .rotation = ska_math_lerpf(tA->rotation, tB->rotation, alpha) + }; +} + +// --- Transform2D Model --- // +SkaTransform2D ska_transform2d_model_convert_to_transform(SkaTransformModel2D* transformModel2D) { + SkaTransform2D transform2D; + ska_transform2d_mat4_to_transform(transformModel2D->model, &transform2D); + // Update scale sign + transform2D.scale = (SkaVector2){ .x = transform2D.scale.x * transformModel2D->scaleSign.x, .y = transform2D.scale.y * transformModel2D->scaleSign.y }; + return transform2D; +} + +// --- Color --- // +SkaColor ska_color_get_normalized_color_default_alpha(uint32 r, uint32 g, uint32 b) { + SkaColor color = { + .r = (f32) r / 255.0f, + .g = (f32) g / 255.0f, + .b = (f32) b / 255.0f, + .a = 1.0f + }; + return color; +} + +SkaColor ska_color_get_normalized_color(uint32 r, uint32 g, uint32 b, uint32 a) { + SkaColor color = { + .r = (f32) r / 255.0f, + .g = (f32) g / 255.0f, + .b = (f32) b / 255.0f, + .a = (f32) a / 255.0f + }; + return color; +} + +SkaColor ska_color_get_normalized_color_from_color(const SkaColor* color) { + SkaColor newColor = { + .r = color->r / 255.0f, + .g = color->g / 255.0f, + .b = color->b / 255.0f, + .a = color->a / 255.0f + }; + return newColor; +} + +SkaVector2 ska_math_minmax_vec2_get_random_in_range(const SkaMinMaxVec2* minmax) { + const SkaVector2 randomVector = { + .x = minmax->min.x + (f32)rand() / RAND_MAX * (minmax->max.x - minmax->min.x), + .y = minmax->min.y + (f32)rand() / RAND_MAX * (minmax->max.y - minmax->min.y), + }; + return randomVector; +} + +// --- Misc --- // +f32 ska_math_lerpf(f32 a, f32 b, f32 alpha) { + return a + (b - a) * alpha; +} + +f32 ska_math_map_to_range(f32 input, f32 inputMin, f32 inputMax, f32 outputMin, f32 outputMax) { + return (((input - inputMin) / (inputMax - inputMin)) * (outputMax - outputMin) + outputMin); +} + +f32 ska_math_map_to_unit(f32 input, f32 inputMin, f32 inputMax) { + return ska_math_map_to_range(input, inputMin, inputMax, 0.0f, 1.0f); +} + +f64 ska_math_map_to_range_double(f64 input, f64 inputMin, f64 inputMax, f64 outputMin, f64 outputMax) { + return (((input - inputMin) / (inputMax - inputMin)) * (outputMax - outputMin) + outputMin); +} + +f64 ska_math_map_to_unit_double(f64 input, f64 inputMin, f64 inputMax) { + return ska_math_map_to_range_double(input, inputMin, inputMax, 0.0, 1.0); +} + +f32 ska_math_signf(f32 value) { + if (value > 0.0f) { + return 1.0f; + } else if(value < 0.0f) { + return -1.0f; + } + return 0.0f; +} + +SkaVector2 ska_math_signvec2(SkaVector2* value) { + SkaVector2 sign_vec = { + .x = ska_math_signf(value->x), + .y = ska_math_signf(value->y) + }; + return sign_vec; +} + +int ska_math_clamp_int(int value, int min, int max) { + return value < min ? min : (value > max ? max : value); +} + +f32 ska_math_clamp_float(f32 value, f32 min, f32 max) { + return value < min ? min : (value > max ? max : value); +} + +bool ska_math_is_almost_equal_float(f32 v1, f32 v2, f32 epsilon) { + return fabsf(v1 - v2) <= epsilon; +} + +bool ska_math_is_almost_equal_float_default(f32 v1, f32 v2) { + static const f64 epsilon = 0.001f; + return fabsf(v1 - v2) <= epsilon; +} + +bool ska_math_is_almost_equal_double(f64 v1, f64 v2, f64 epsilon) { + return fabs(v1 - v2) <= epsilon; +} + +bool ska_math_is_almost_equal_double_default(f64 v1, f64 v2) { + static const f64 epsilon = 0.001; + return fabs(v1 - v2) <= epsilon; +} diff --git a/seika1/math/math.h b/seika1/math/math.h new file mode 100644 index 0000000..837cd2e --- /dev/null +++ b/seika1/math/math.h @@ -0,0 +1,180 @@ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef _MSC_VER +#define CGLM_ALL_UNALIGNED +#endif + +#include + +#include "seika/defines.h" + +#define SKA_PI 3.14159265358979323846f +#define SKA_RAD_2_DEG(RADIANS) ((RADIANS) * (180.0 / (f64)SKA_PI)) +#define SKA_RAD_2_DEGF(RADIANS) ((RADIANS) * (180.0f / SKA_PI)) +#define SKA_DEG_2_RAD(DEGREES) ((DEGREES) * ((f64)SKA_PI / 180.0)) +#define SKA_DEG_2_RADF(DEGREES) ((DEGREES) * (SKA_PI / 180.0f)) + + +// --- SkaVector2 --- // +typedef struct SkaVector2 { + f32 x; + f32 y; +} SkaVector2; + +#define SKA_VECTOR2_ZERO SKA_STRUCT_LITERAL(SkaVector2){ 0.0f, 0.0f } +#define SKA_VECTOR2_ONE SKA_STRUCT_LITERAL(SkaVector2){ 1.0f, 1.0f } +#define SKA_VECTOR2_LEFT SKA_STRUCT_LITERAL(SkaVector2){ -1.0f, 0.0f } +#define SKA_VECTOR2_RIGHT SKA_STRUCT_LITERAL(SkaVector2){ 1.0f, 0.0f } +#define SKA_VECTOR2_UP SKA_STRUCT_LITERAL(SkaVector2){ 0.0f, -1.0f } +#define SKA_VECTOR2_DOWN SKA_STRUCT_LITERAL(SkaVector2){ 0.0f, 1.0f } + +bool ska_math_vec2_equals(const SkaVector2* v1, const SkaVector2* v2); +SkaVector2 ska_math_vec2_lerp(const SkaVector2* v1, const SkaVector2* v2, f32 alpha); +f32 ska_math_vec2_angle(const SkaVector2* v); + +// --- SkaVector2i --- // +typedef struct SkaVector2i { + int32 x; + int32 y; +} SkaVector2i; + +#define SKA_VECTOR2I_ZERO SKA_STRUCT_LITERAL(SkaVector2i){ 0, 0 } +#define SKA_VECTOR2I_ONE SKA_STRUCT_LITERAL(SkaVector2i){ 1, 1 } +#define SKA_VECTOR2I_LEFT SKA_STRUCT_LITERAL(SkaVector2i){ -1, 0 } +#define SKA_VECTOR2I_RIGHT SKA_STRUCT_LITERAL(SkaVector2i){ 1, 0 } +#define SKA_VECTOR2I_UP SKA_STRUCT_LITERAL(SkaVector2i){ 0, -1 } +#define SKA_VECTOR2I_DOWN SKA_STRUCT_LITERAL(SkaVector2i){ 0, 1 } + +// --- SkaSize2D --- // +typedef struct SkaSize2D { + f32 w; + f32 h; +} SkaSize2D; + +#define SKA_SIZE2D_ZERO SKA_STRUCT_LITERAL(SkaSize2D){ 0.0f, 0.0f } + +// --- SkaSize2Di --- // +typedef struct SkaSize2Di { + int32 w; + int32 h; +} SkaSize2Di; + +#define SKA_SIZE2DI_ZERO SKA_STRUCT_LITERAL(SkaSize2Di){ 0, 0 } + +// --- SkaRect2 --- // +typedef struct SkaRect2 { + f32 x; + f32 y; + f32 w; + f32 h; +} SkaRect2; + +#define SKA_RECT2D_ZERO SKA_STRUCT_LITERAL(SkaRect2){ 0.0f, 0.0f, 0.0f, 0.0f } + +bool se_rect2_does_rectangles_overlap(const SkaRect2* sourceRect, const SkaRect2* targetRect); + +//--- SkaTransform2D ---// +typedef struct SkaTransform2D { + SkaVector2 position; + SkaVector2 scale; + f32 rotation; // degrees +} SkaTransform2D; + +void ska_transform2d_mat4_to_transform(mat4 matrix, SkaTransform2D* transform); +void ska_transform2d_transform_to_mat4(const SkaTransform2D* transform, mat4 matrix); +SkaTransform2D ska_transform2d_lerp(const SkaTransform2D* tA, const SkaTransform2D* tB, f32 alpha); + +#define SKA_TRANSFORM_IDENTITY SKA_STRUCT_LITERAL(SkaTransform2D){ \ + .position = SKA_VECTOR2_ZERO, \ + .scale = SKA_VECTOR2_ONE, \ + .rotation = 0.0f \ +} + +typedef struct SkaTransformModel2D { + SkaVector2 position; + SkaVector2 scale; + f32 rotation; // degrees + int32 zIndex; + SkaVector2 scaleSign; + mat4 model; +} SkaTransformModel2D; + +SkaTransform2D ska_transform2d_model_convert_to_transform(SkaTransformModel2D* transformModel2D); + +#define SKA_TRANSFORM_MODEL_IDENTITY SKA_STRUCT_LITERAL(SkaTransformModel2D){ \ + .position = SKA_VECTOR2_ZERO, \ + .scale = SKA_VECTOR2_ONE, \ + .rotation = 0.0f, \ + .zIndex = 0, \ + .scaleSign = SKA_VECTOR2_ONE \ +} + +// --- SkaVector3 --- // +typedef struct SkaVector3 { + f32 x; + f32 y; + f32 z; +} SkaVector3; + +// --- SkaVector4 --- // +typedef struct SkaVector4 { + f32 x; + f32 y; + f32 z; + f32 w; +} SkaVector4; + +// --- SkaColor --- // +typedef struct SkaColor { + f32 r; + f32 g; + f32 b; + f32 a; +} SkaColor; + +#define SKA_COLOR_WHITE SKA_STRUCT_LITERAL(SkaColor){ 1.0f, 1.0f, 1.0f, 1.0f } +#define SKA_COLOR_BLACK SKA_STRUCT_LITERAL(SkaColor){ 0.0f, 0.0f, 0.0f, 1.0f } +#define SKA_COLOR_RED SKA_STRUCT_LITERAL(SkaColor){ 1.0f, 0.0f, 0.0f, 1.0f } +#define SKA_COLOR_GREEN SKA_STRUCT_LITERAL(SkaColor){ 0.0f, 1.0f, 0.0f, 1.0f } +#define SKA_COLOR_BLUE SKA_STRUCT_LITERAL(SkaColor){ 0.0f, 0.0f, 1.0f, 1.0f } + +SkaColor ska_color_get_normalized_color_default_alpha(uint32 r, uint32 g, uint32 b); +SkaColor ska_color_get_normalized_color(uint32 r, uint32 g, uint32 b, uint32 a); +SkaColor ska_color_get_normalized_color_from_color(const SkaColor* color); + +// --- SkaMinMaxVec2 --- // +typedef struct SkaMinMaxVec2 { + SkaVector2 min; + SkaVector2 max; +} SkaMinMaxVec2; + +#define SKA_MINMAX_VEC2_ZERO SKA_STRUCT_LITERAL(SkaMinMaxVec2){ SKA_VECTOR2_ZERO, SKA_VECTOR2_ZERO } + +SkaVector2 ska_math_minmax_vec2_get_random_in_range(const SkaMinMaxVec2* minmax); + +// --- Misc --- // +#define SKA_MATH_MIN(A, B) ((A) < (B) ? (A) : (B)) +#define SKA_MATH_MAX(A, B) ((A) > (B) ? (A) : (B)) +#define SKA_MATH_CLAMP(VAL, MIN_VAL, MAX_VAL) ((VAL) < (MIN_VAL) ? (MIN_VAL) : (VAL) > (MAX_VAL) ? (MAX_VAL) : (VAL)) + +f32 ska_math_lerpf(f32 a, f32 b, f32 alpha); +f32 ska_math_map_to_range(f32 input, f32 inputMin, f32 inputMax, f32 outputMin, f32 outputMax); +f32 ska_math_map_to_unit(f32 input, f32 inputMin, f32 inputMax); +f64 ska_math_map_to_range_double(f64 input, f64 inputMin, f64 inputMax, f64 outputMin, f64 outputMax); +f64 ska_math_map_to_unit_double(f64 input, f64 inputMin, f64 inputMax); +f32 ska_math_signf(f32 value); +SkaVector2 ska_math_signvec2(SkaVector2* value); +int32 ska_math_clamp_int(int32 value, int32 min, int32 max); +f32 ska_math_clamp_float(f32 value, f32 min, f32 max); +bool ska_math_is_almost_equal_float(f32 v1, f32 v2, f32 epsilon); +bool ska_math_is_almost_equal_float_default(f32 v1, f32 v2); +bool ska_math_is_almost_equal_double(f64 v1, f64 v2, f64 epsilon); +bool ska_math_is_almost_equal_double_default(f64 v1, f64 v2); + +#ifdef __cplusplus +} +#endif From 55f88197ba4d7401de54ba3bfd6977a7d391712a Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 10 Oct 2024 23:15:46 -0400 Subject: [PATCH 05/55] Updates. --- CMakeLists.txt | 3 + seika1/assert.c | 10 +- seika1/assert.h | 5 +- seika1/data_structures/array2d.c | 4 +- seika1/data_structures/array2d.h | 2 +- seika1/data_structures/array_list.c | 4 +- seika1/data_structures/array_list.h | 2 +- seika1/data_structures/array_utils.h | 2 +- seika1/data_structures/hash_map.c | 4 +- seika1/data_structures/hash_map.h | 5 +- seika1/data_structures/hash_map_string.c | 6 +- seika1/data_structures/hash_map_string.h | 2 +- seika1/data_structures/queue.c | 2 +- seika1/data_structures/queue.h | 2 +- seika1/data_structures/spatial_hash_map.c | 4 +- seika1/data_structures/spatial_hash_map.h | 4 +- seika1/data_structures/static_array.h | 4 +- seika1/defines.h | 2 +- seika1/logger.c | 2 +- seika1/logger.h | 2 +- seika1/math/curve_float.c | 4 +- seika1/math/curve_float.h | 5 +- seika1/math/math.h | 2 +- seika1/memory.c | 128 ++++++++++++++++++++-- seika1/memory.h | 34 ++++-- seika1/platform.h | 2 +- seika1/string.c | 5 +- seika1/string.h | 2 +- 28 files changed, 186 insertions(+), 67 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 9545718..ee0eb2b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -26,4 +26,7 @@ if (SK_IS_MAIN) # Create seika test exe add_executable(seika_test test/test.c) target_link_libraries(seika_test seika unity) + # Create seika1 test exe + add_executable(seika1_test test/test1.c) + target_link_libraries(seika1_test seika1 unity) endif() diff --git a/seika1/assert.c b/seika1/assert.c index 7f90104..6f61759 100644 --- a/seika1/assert.c +++ b/seika1/assert.c @@ -1,16 +1,20 @@ -#include "seika/assert.h" +#include "seika1/assert.h" +#include +#include #include +#include "seika1/string.h" + void ska_print_assert_err(const char* fmt, ...) { #define SKA_PRINT_BUFFER_SIZE 496 va_list args; - va_start(args, fmt); + va_start(args, fmt); char str[SKA_PRINT_BUFFER_SIZE]; memset(str, 0, SKA_PRINT_BUFFER_SIZE); ska_strncat(str, fmt, (sizeof(str) - strlen(str) - 1) ); ska_strncat(str, "\n", (sizeof(str) - strlen(str) - 1) ); vfprintf(stderr, str, args); - va_end(args); + va_end(args); #undef SKA_PRINT_BUFFER_SIZE } diff --git a/seika1/assert.h b/seika1/assert.h index dc92906..0ad4b0c 100644 --- a/seika1/assert.h +++ b/seika1/assert.h @@ -9,9 +9,8 @@ extern "C" { #include #include -#include "defines.h" -#include "platform.h" -#include "seika1/string.h" +#include "seika1/defines.h" +#include "seika1/platform.h" #define SKA_ASSERT_FAIL_EXIT_CODE (-1) diff --git a/seika1/data_structures/array2d.c b/seika1/data_structures/array2d.c index cd7d3ed..8023dcf 100644 --- a/seika1/data_structures/array2d.c +++ b/seika1/data_structures/array2d.c @@ -2,8 +2,8 @@ #include -#include "seika/memory.h" -#include "seika/assert.h" +#include "seika1/memory.h" +#include "seika1/assert.h" #define SKA_ARRAY2D_IS_COORD_INVALID(ARRAY2D, ROW, COL) ((int32)ROW >= ARRAY2D->size.w || (int32)COL >= ARRAY2D->size.h) diff --git a/seika1/data_structures/array2d.h b/seika1/data_structures/array2d.h index f2c9cc0..b5c4d2d 100644 --- a/seika1/data_structures/array2d.h +++ b/seika1/data_structures/array2d.h @@ -1,6 +1,6 @@ #pragma once -#include "seika/math/math.h" +#include "seika1/math/math.h" typedef struct SkaArray2D { void** data; diff --git a/seika1/data_structures/array_list.c b/seika1/data_structures/array_list.c index 0e94f17..d8a3203 100644 --- a/seika1/data_structures/array_list.c +++ b/seika1/data_structures/array_list.c @@ -2,8 +2,8 @@ #include -#include "seika/memory.h" -#include "seika/assert.h" +#include "seika1/memory.h" +#include "seika1/assert.h" #define SKA_ARRAY_LIST_DEFAULT_CAPACITY 16 diff --git a/seika1/data_structures/array_list.h b/seika1/data_structures/array_list.h index d03a6ff..ea6542c 100644 --- a/seika1/data_structures/array_list.h +++ b/seika1/data_structures/array_list.h @@ -1,6 +1,6 @@ #pragma once -#include "seika/defines.h" +#include "seika1/defines.h" #define SKA_ARRAY_LIST_GET_ARRAY(LIST, TYPE) ((TYPE*)((LIST)->data)) #define SKA_ARRAY_LIST_FOR_EACH(LIST, TYPE, VALUE) for(TYPE* VALUE = SKA_ARRAY_LIST_GET_ARRAY(LIST, TYPE), *VALUE##_end = VALUE + (LIST)->size; VALUE < VALUE##_end; VALUE++) diff --git a/seika1/data_structures/array_utils.h b/seika1/data_structures/array_utils.h index 14cb3c3..e0d3846 100644 --- a/seika1/data_structures/array_utils.h +++ b/seika1/data_structures/array_utils.h @@ -1,6 +1,6 @@ #pragma once -#include "seika/defines.h" +#include "seika1/defines.h" #define SKA_ARRAY_UTILS_REMOVE_ARRAY_ITEM(ARRAY, ARRAY_SIZE, ELEMENT, EMPTY_VALUE) \ { \ diff --git a/seika1/data_structures/hash_map.c b/seika1/data_structures/hash_map.c index 3c77f5f..baedbd0 100644 --- a/seika1/data_structures/hash_map.c +++ b/seika1/data_structures/hash_map.c @@ -2,8 +2,8 @@ #include -#include "seika/memory.h" -#include "seika/assert.h" +#include "seika1/memory.h" +#include "seika1/assert.h" static usize se_default_hash(void* raw_key, usize key_size); static int32 se_default_compare(void* first_key, void* second_key, usize key_size); diff --git a/seika1/data_structures/hash_map.h b/seika1/data_structures/hash_map.h index 852c99a..ff29c87 100644 --- a/seika1/data_structures/hash_map.h +++ b/seika1/data_structures/hash_map.h @@ -4,10 +4,7 @@ extern "C" { #endif -#include -#include - -#include "seika/defines.h" +#include "seika1/defines.h" #define SKA_HASH_MAP_SHRINK_THRESHOLD 0.25f #define SKA_HASH_MAP_MIN_CAPACITY 8 diff --git a/seika1/data_structures/hash_map_string.c b/seika1/data_structures/hash_map_string.c index f090614..9c8ed2f 100644 --- a/seika1/data_structures/hash_map_string.c +++ b/seika1/data_structures/hash_map_string.c @@ -2,9 +2,9 @@ #include -#include "seika/string.h" -#include "seika/memory.h" -#include "seika/assert.h" +#include "seika1/string.h" +#include "seika1/memory.h" +#include "seika1/assert.h" static usize ska_default_hash_string(const char* raw_key); static int32 ska_default_compare_string(const char* first_key, const char* second_key); diff --git a/seika1/data_structures/hash_map_string.h b/seika1/data_structures/hash_map_string.h index 658c336..2d484a6 100644 --- a/seika1/data_structures/hash_map_string.h +++ b/seika1/data_structures/hash_map_string.h @@ -4,7 +4,7 @@ extern "C" { #endif -#include "seika/defines.h" +#include "seika1/defines.h" #define SKA_STRING_HASH_MAP_SHRINK_THRESHOLD 0.25f #define SKA_STRING_HASH_MAP_MIN_CAPACITY 8 diff --git a/seika1/data_structures/queue.c b/seika1/data_structures/queue.c index 9bd2599..711cb4f 100644 --- a/seika1/data_structures/queue.c +++ b/seika1/data_structures/queue.c @@ -1,6 +1,6 @@ #include "queue.h" -#include "seika/memory.h" +#include "seika1/memory.h" SkaQueue* ska_queue_create(usize capacity, uint32 invalidValue) { SkaQueue* queue = SKA_MEM_ALLOCATE(SkaQueue); diff --git a/seika1/data_structures/queue.h b/seika1/data_structures/queue.h index 9749be5..0c08018 100644 --- a/seika1/data_structures/queue.h +++ b/seika1/data_structures/queue.h @@ -1,6 +1,6 @@ #pragma once -#include "seika/defines.h" +#include "seika1/defines.h" // TODO: If other types are needed, create a macro to simplify queues by type diff --git a/seika1/data_structures/spatial_hash_map.c b/seika1/data_structures/spatial_hash_map.c index b66a822..b166a74 100644 --- a/seika1/data_structures/spatial_hash_map.c +++ b/seika1/data_structures/spatial_hash_map.c @@ -3,8 +3,8 @@ #include #include -#include "seika/memory.h" -#include "seika/assert.h" +#include "seika1/memory.h" +#include "seika1/assert.h" #define SKA_SPATIAL_HASH_NULL_ENTITY 4294967295 #define SKA_SPATIAL_HASH_MAX_POSITION_HASH 8 diff --git a/seika1/data_structures/spatial_hash_map.h b/seika1/data_structures/spatial_hash_map.h index 37acb34..a5a6242 100644 --- a/seika1/data_structures/spatial_hash_map.h +++ b/seika1/data_structures/spatial_hash_map.h @@ -1,7 +1,7 @@ #pragma once -#include "seika/math/math.h" -#include "seika/data_structures/hash_map.h" +#include "seika1/math/math.h" +#include "seika1/data_structures/hash_map.h" #define SKA_SPATIAL_HASH_GRID_SPACE_ENTITY_LIMIT 32 #define SKA_SPATIAL_HASH_GRID_MAX_COLLISIONS 16 diff --git a/seika1/data_structures/static_array.h b/seika1/data_structures/static_array.h index 05caa9a..b0ded8d 100644 --- a/seika1/data_structures/static_array.h +++ b/seika1/data_structures/static_array.h @@ -1,7 +1,7 @@ #pragma once -#include "seika/defines.h" -#include "seika/data_structures/array_utils.h" +#include "seika1/defines.h" +#include "seika1/data_structures/array_utils.h" // Helper class for generalized use of static arrays diff --git a/seika1/defines.h b/seika1/defines.h index d08caf5..92d8ff0 100644 --- a/seika1/defines.h +++ b/seika1/defines.h @@ -8,7 +8,7 @@ extern "C" { #include #include -#include "seika/version_info.h" +#include "seika1/version_info.h" // Compilation modes diff --git a/seika1/logger.c b/seika1/logger.c index 6111a2d..279bd6b 100644 --- a/seika1/logger.c +++ b/seika1/logger.c @@ -4,7 +4,7 @@ #include #include -#include "seika/string.h" +#include "seika1/string.h" #include "memory.h" #define SKA_LOGGER_MAX_QUEUED_MESSAGES 16 diff --git a/seika1/logger.h b/seika1/logger.h index 32c9abd..437e33e 100644 --- a/seika1/logger.h +++ b/seika1/logger.h @@ -4,7 +4,7 @@ extern "C" { #endif -#include +#include "seika/defines.h" #ifndef SKA_LOG_BUFFER_SIZE #define SKA_LOG_BUFFER_SIZE 512 diff --git a/seika1/math/curve_float.c b/seika1/math/curve_float.c index d5197fb..07c9131 100644 --- a/seika1/math/curve_float.c +++ b/seika1/math/curve_float.c @@ -1,7 +1,7 @@ #include "curve_float.h" -#include "seika/math/math.h" -#include "seika/assert.h" +#include "seika1/math/math.h" +#include "seika1/assert.h" // Helper functions void control_point_swap(SkaCurveControlPoint* pointA, SkaCurveControlPoint* pointB) { diff --git a/seika1/math/curve_float.h b/seika1/math/curve_float.h index 16ed517..344d2bf 100644 --- a/seika1/math/curve_float.h +++ b/seika1/math/curve_float.h @@ -4,10 +4,7 @@ extern "C" { #endif -#include -#include - -#include "seika/defines.h" +#include "seika1/defines.h" #define SKA_CURVE_MAX_CONTROL_POINTS 16 diff --git a/seika1/math/math.h b/seika1/math/math.h index 837cd2e..b28d498 100644 --- a/seika1/math/math.h +++ b/seika1/math/math.h @@ -10,7 +10,7 @@ extern "C" { #include -#include "seika/defines.h" +#include "seika1/defines.h" #define SKA_PI 3.14159265358979323846f #define SKA_RAD_2_DEG(RADIANS) ((RADIANS) * (180.0 / (f64)SKA_PI)) diff --git a/seika1/memory.c b/seika1/memory.c index e4e41ef..d7c9da6 100644 --- a/seika1/memory.c +++ b/seika1/memory.c @@ -1,25 +1,129 @@ -#include "seika/memory.h" -#include "seika/assert.h" +#include "seika1/memory.h" +#include "seika1/assert.h" -void* ska_mem_allocate(usize size) { - void* memory = calloc(1, size); - SKA_ASSERT_FMT(memory, "Out of memory or allocate failed!, size = %d", size); +// Internal default allocator implementation + +typedef struct Allocation { + const void* ptr; + usize bytes; + struct Allocation* next; +} Allocation; + +static Allocation* allocationList = NULL; + +static void track_allocation(const void* memory, usize bytes) { + Allocation* newAlloc = (Allocation*)malloc(sizeof(Allocation)); + SKA_ASSERT(newAlloc); + newAlloc->ptr = memory; + newAlloc->bytes = bytes; + newAlloc->next = allocationList; + allocationList = newAlloc; +} + +static void untrack_allocation(const void* memory) { + Allocation* current = allocationList; + Allocation* prev = NULL; + while (current) { + if (current->ptr == memory) { + if (prev) { + prev->next = current->next; + } else { + allocationList = current->next; + } + free(current); + return; + } + prev = current; + current = current->next; + } +} + +static bool isAllocatorValid(const SkaMemAllocator* allocator) { + return allocator->allocate + && allocator->allocate_zeroed + && allocator->reallocate + && allocator->free + && allocator->report_leaks; +} + +static void* internal_mem_allocate(usize bytes) { + void* memory = malloc(bytes); + SKA_ASSERT_FMT(memory, "Out of memory or allocation failed!, size = %d", bytes); + track_allocation(memory, bytes); return memory; } -void* ska_mem_allocate_c(usize blocks, usize size) { - void* memory = calloc(blocks, size); - SKA_ASSERT_FMT(memory, "Out of memory or allocate_c failed!, size = %d", size); +static void* internal_mem_allocate_zeroed(usize bytes) { + void* memory = calloc(1, bytes); + SKA_ASSERT_FMT(memory, "Out of memory or allocation failed!, size = %d", bytes); + track_allocation(memory, bytes); return memory; } -void* ska_mem_reallocate(void* memory, usize size) { - void* reallocatedMemory = realloc(memory, size); - SKA_ASSERT_FMT(reallocatedMemory, "Out of memory or realloc failed!, size = %d", size); +static void* internal_mem_reallocate(void* memory, usize bytes) { + untrack_allocation(memory); + void* reallocatedMemory = realloc(memory, bytes); + SKA_ASSERT_FMT(reallocatedMemory, "Out of memory or realloc failed!, size = %d", bytes); + track_allocation(reallocatedMemory, bytes); return reallocatedMemory; } -void ska_mem_free(void* memory) { +static void internal_mem_free(void* memory) { + untrack_allocation(memory); free(memory); memory = NULL; } + +static bool internal_mem_report_leaks() { + // If there is an allocation list there is a memory leak + return allocationList != NULL; +} + +static const SkaMemAllocator defaultAlloc = { + .allocate = internal_mem_allocate, + .allocate_zeroed = internal_mem_allocate_zeroed, + .reallocate = internal_mem_reallocate, + .free = internal_mem_free, + .report_leaks = internal_mem_report_leaks +}; + +static SkaMemAllocator currentAlloc = defaultAlloc; + +void ska_set_current_allocator(const SkaMemAllocator allocator) { + SKA_ASSERT_FMT(isAllocatorValid(&allocator), "Must implement all allocator functions before setting"); + currentAlloc = allocator; +} + +const SkaMemAllocator* ska_mem_get_current_allocator() { + return ¤tAlloc; +} + +void ska_reset_to_default_allocator() { + currentAlloc = defaultAlloc; +} + +void* ska_mem_allocate(usize bytes) { + void* memory = currentAlloc.allocate(bytes); + SKA_ASSERT_FMT(memory, "Out of memory or allocation failed!, size = %d", bytes); + return memory; +} + +void* ska_mem_allocate_zeroed(usize bytes) { + void* memory = currentAlloc.allocate_zeroed(bytes); + SKA_ASSERT_FMT(memory, "Out of memory or allocation failed!, size = %d", bytes); + return memory; +} + +void* ska_mem_reallocate(void* memory, usize bytes) { + void* reallocatedMemory = currentAlloc.reallocate(memory, bytes); + SKA_ASSERT_FMT(reallocatedMemory, "Out of memory or realloc failed!, size = %d", bytes); + return reallocatedMemory; +} + +void ska_mem_free(void* memory) { + currentAlloc.free(memory); +} + +bool ska_mem_report_leaks() { + return currentAlloc.report_leaks(); +} diff --git a/seika1/memory.h b/seika1/memory.h index 677ac41..cb4f749 100644 --- a/seika1/memory.h +++ b/seika1/memory.h @@ -4,27 +4,43 @@ extern "C" { #endif -#include "defines.h" +#include "seika/defines.h" #define SKA_MEM_ALLOCATE(DataType) \ (DataType*) ska_mem_allocate(sizeof(DataType)) #define SKA_MEM_ALLOCATE_ARRAY(DataType, ArraySize) \ -(DataType*) ska_mem_allocate_c(ArraySize, sizeof(DataType)) +(DataType*) ska_mem_allocate(ArraySize * sizeof(DataType)) -#define SKA_MEM_ALLOCATE_SIZE(Size) \ -ska_mem_allocate(Size) +#define SKA_MEM_ALLOCATE_SIZE(Bytes) \ +ska_mem_allocate(Bytes) -#define SKA_MEM_ALLOCATE_SIZE_ZERO(Blocks, Size) \ -ska_mem_allocate_c(Blocks, Size) +#define SKA_MEM_ALLOCATE_SIZE_ZERO(Blocks, Bytes) \ +ska_mem_allocate(Blocks * Bytes) #define SKA_MEM_FREE(Memory) \ ska_mem_free(Memory) -void* ska_mem_allocate(usize size); -void* ska_mem_allocate_c(usize blocks, usize size); -void* ska_mem_reallocate(void* memory, usize size); +typedef struct SkaMemAllocator { + void* (*allocate)(usize bytes); + void* (*allocate_zeroed)(usize bytes); + void* (*reallocate)(void* memory, usize bytes); + void (*free)(void* memory); + bool (*report_leaks)(void); +} SkaMemAllocator; + +void ska_mem_set_current_allocator(const SkaMemAllocator allocator); +const SkaMemAllocator* ska_mem_get_current_allocator(); +void ska_mem_reset_to_default_allocator(); + + +// Calls using the current allocator + +void* ska_mem_allocate(usize bytes); +void* ska_mem_allocate_zeroed(usize bytes); +void* ska_mem_reallocate(void* memory, usize bytes); void ska_mem_free(void* memory); +bool ska_mem_report_leaks(); #ifdef __cplusplus } diff --git a/seika1/platform.h b/seika1/platform.h index a63be05..d3136dd 100644 --- a/seika1/platform.h +++ b/seika1/platform.h @@ -4,7 +4,7 @@ extern "C" { #endif -#include "seika/defines.h" +#include "seika1/defines.h" #if defined(_WIN32) || defined(_WIN64) // Windows #define SKA_TRIGGER_BREAKPOINT __debugbreak() diff --git a/seika1/string.c b/seika1/string.c index 0675da8..664cee0 100644 --- a/seika1/string.c +++ b/seika1/string.c @@ -1,10 +1,9 @@ -#include "seika/string.h" +#include "seika1/string.h" -#include #include #include -#include "seika/memory.h" +#include "seika1/memory.h" #ifdef _MSC_VER #pragma warning(disable : 4996) // for strcpy and strncat diff --git a/seika1/string.h b/seika1/string.h index b872934..3b5a572 100644 --- a/seika1/string.h +++ b/seika1/string.h @@ -1,6 +1,6 @@ #pragma once -#include "seika/defines.h" +#include "seika1/defines.h" // Copies string and allocated new memory char* ska_strdup(const char* string); From 722f45f2cbe0925e855096d7877f5e5ebc29d672 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 10 Oct 2024 23:16:25 -0400 Subject: [PATCH 06/55] Forgot to add test file> --- test/test1.c | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 test/test1.c diff --git a/test/test1.c b/test/test1.c new file mode 100644 index 0000000..7135a58 --- /dev/null +++ b/test/test1.c @@ -0,0 +1,28 @@ +#include +#include + +#include "seika1/memory.h" + +#define RESOURCES_PATH "test/resources" +#define RESOURCES_PACK_PATH "test/resources/test.pck" + +void setUp(void) {} +void tearDown(void) {} + +void seika_mem_test(void); + +int32 main(int32 argv, char** args) { + UNITY_BEGIN(); + RUN_TEST(seika_mem_test); + return UNITY_END(); +} + +void seika_mem_test(void) { + int* testInt = SKA_MEM_ALLOCATE(int); + TEST_ASSERT_NOT_NULL(testInt); + *testInt = 5; + TEST_ASSERT_EQUAL_INT(5, *testInt); + TEST_ASSERT_TRUE(ska_mem_report_leaks()); + SKA_MEM_FREE(testInt); + TEST_ASSERT_FALSE(ska_mem_report_leaks()); +} From 4ab7f284d42b9cebc53fe18a110e119de83c8868 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 10 Oct 2024 23:27:09 -0400 Subject: [PATCH 07/55] Updates. --- seika1/data_structures/array2d.c | 20 ++++++++++---------- seika1/data_structures/array_list.c | 8 ++++---- seika1/data_structures/hash_map.c | 12 ++++++------ seika1/data_structures/hash_map_string.c | 22 +++++++++++----------- seika1/data_structures/queue.c | 8 ++++---- seika1/data_structures/spatial_hash_map.c | 14 +++++++------- seika1/memory.h | 14 +++++++------- seika1/string.c | 12 ++++++------ test/test1.c | 4 ++-- 9 files changed, 57 insertions(+), 57 deletions(-) diff --git a/seika1/data_structures/array2d.c b/seika1/data_structures/array2d.c index 8023dcf..42c3b6c 100644 --- a/seika1/data_structures/array2d.c +++ b/seika1/data_structures/array2d.c @@ -8,10 +8,10 @@ #define SKA_ARRAY2D_IS_COORD_INVALID(ARRAY2D, ROW, COL) ((int32)ROW >= ARRAY2D->size.w || (int32)COL >= ARRAY2D->size.h) SkaArray2D* ska_array2d_create(usize rows, usize cols, usize elementSize) { - SkaArray2D* newArray = SKA_MEM_ALLOCATE(SkaArray2D); - newArray->data = SKA_MEM_ALLOCATE_SIZE(cols * sizeof(void*)); + SkaArray2D* newArray = SKA_ALLOC(SkaArray2D); + newArray->data = SKA_ALLOC_BYTES(cols * sizeof(void*)); for (usize i = 0; i < cols; i++) { - newArray->data[i] = SKA_MEM_ALLOCATE_SIZE(rows * elementSize); + newArray->data[i] = SKA_ALLOC_BYTES(rows * elementSize); } newArray->size = (SkaSize2Di){ .w = (int32)rows, .h = (int32)cols }; newArray->elementSize = elementSize; @@ -20,10 +20,10 @@ SkaArray2D* ska_array2d_create(usize rows, usize cols, usize elementSize) { void ska_array2d_destroy(SkaArray2D* array2d) { for (int32 i = 0; i < array2d->size.h; i++) { - SKA_MEM_FREE(array2d->data[i]); + SKA_FREE(array2d->data[i]); } - SKA_MEM_FREE(array2d->data); - SKA_MEM_FREE(array2d); + SKA_FREE(array2d->data); + SKA_FREE(array2d); } void* ska_array2d_get(SkaArray2D* array2d, usize x, usize y) { @@ -49,11 +49,11 @@ void ska_array2d_resize(SkaArray2D* array2d, usize newX, usize newY) { void** oldData = array2d->data; const SkaSize2Di oldSize = array2d->size; // Allocate data for all columns - array2d->data = SKA_MEM_ALLOCATE_SIZE(newHeight * sizeof(void*)); + array2d->data = SKA_ALLOC_BYTES(newHeight * sizeof(void*)); // Iterate over new rows for (usize i = 0; i < newHeight; i++) { // Allocate data for new row - array2d->data[i] = SKA_MEM_ALLOCATE_SIZE(newX * array2d->elementSize); + array2d->data[i] = SKA_ALLOC_BYTES(newX * array2d->elementSize); if (i < (usize)oldSize.h) { // Now copy old data const usize bytesToCopy = SKA_MATH_MIN((usize)oldSize.w, newWidth) * array2d->elementSize; @@ -68,9 +68,9 @@ void ska_array2d_resize(SkaArray2D* array2d, usize newX, usize newY) { } for (usize i = 0; i < (usize)oldSize.h; i++) { - SKA_MEM_FREE(oldData[i]); + SKA_FREE(oldData[i]); } - SKA_MEM_FREE(oldData); + SKA_FREE(oldData); } void ska_array2d_clear(SkaArray2D* array2d) { diff --git a/seika1/data_structures/array_list.c b/seika1/data_structures/array_list.c index d8a3203..3048aa2 100644 --- a/seika1/data_structures/array_list.c +++ b/seika1/data_structures/array_list.c @@ -12,8 +12,8 @@ SkaArrayList* ska_array_list_create_default_capacity(usize valueSize) { } SkaArrayList* ska_array_list_create(usize valueSize, usize initialCapacity) { - SkaArrayList* newList = SKA_MEM_ALLOCATE(SkaArrayList); - newList->data = SKA_MEM_ALLOCATE_SIZE(initialCapacity * valueSize); + SkaArrayList* newList = SKA_ALLOC(SkaArrayList); + newList->data = SKA_ALLOC_BYTES(initialCapacity * valueSize); newList->valueSize = valueSize; newList->capacity = initialCapacity; newList->initialCapacity = initialCapacity; @@ -21,8 +21,8 @@ SkaArrayList* ska_array_list_create(usize valueSize, usize initialCapacity) { } void ska_array_list_destroy(SkaArrayList* list) { - SKA_MEM_FREE(list->data); - SKA_MEM_FREE(list); + SKA_FREE(list->data); + SKA_FREE(list); } void ska_array_list_push_back(SkaArrayList* list, const void* value) { diff --git a/seika1/data_structures/hash_map.c b/seika1/data_structures/hash_map.c index baedbd0..a1dd002 100644 --- a/seika1/data_structures/hash_map.c +++ b/seika1/data_structures/hash_map.c @@ -18,7 +18,7 @@ static void hash_map_allocate(SkaHashMap* hashMap, usize capacity); static void hash_map_resize(SkaHashMap* hashMap, usize capacity); SkaHashMap* ska_hash_map_create(usize keySize, usize valueSize, usize capacity) { - SkaHashMap* map = (SkaHashMap*) SKA_MEM_ALLOCATE_SIZE(sizeof(SkaHashMap)); + SkaHashMap* map = (SkaHashMap*) SKA_ALLOC_BYTES(sizeof(SkaHashMap)); map->keySize = keySize; map->valueSize = valueSize; map->size = 0; @@ -29,9 +29,9 @@ SkaHashMap* ska_hash_map_create(usize keySize, usize valueSize, usize capacity) } SkaHashMapNode* hash_map_create_node(SkaHashMap* hashMap, void* key, void* value, SkaHashMapNode* next) { - SkaHashMapNode* node = (SkaHashMapNode*) SKA_MEM_ALLOCATE(SkaHashMapNode); - node->key = SKA_MEM_ALLOCATE_SIZE(hashMap->keySize); - node->value = SKA_MEM_ALLOCATE_SIZE(hashMap->valueSize); + SkaHashMapNode* node = (SkaHashMapNode*) SKA_ALLOC(SkaHashMapNode); + node->key = SKA_ALLOC_BYTES(hashMap->keySize); + node->value = SKA_ALLOC_BYTES(hashMap->valueSize); memcpy(node->key, key, hashMap->keySize); memcpy(node->value, value, hashMap->valueSize); node->next = next; @@ -50,7 +50,7 @@ bool ska_hash_map_destroy(SkaHashMap* hashMap) { } } - SKA_MEM_FREE(hashMap); + SKA_FREE(hashMap); return true; } @@ -147,7 +147,7 @@ void hash_map_shrink_if_needed(SkaHashMap* hashMap) { } void hash_map_allocate(SkaHashMap* hashMap, usize capacity) { - hashMap->nodes = (SkaHashMapNode**)SKA_MEM_ALLOCATE_SIZE(capacity * sizeof(SkaHashMapNode*)); + hashMap->nodes = (SkaHashMapNode**)SKA_ALLOC_BYTES(capacity * sizeof(SkaHashMapNode*)); memset(hashMap->nodes, 0, capacity * sizeof(SkaHashMapNode*)); hashMap->capacity = capacity; diff --git a/seika1/data_structures/hash_map_string.c b/seika1/data_structures/hash_map_string.c index 9c8ed2f..b998cc3 100644 --- a/seika1/data_structures/hash_map_string.c +++ b/seika1/data_structures/hash_map_string.c @@ -20,12 +20,12 @@ static void string_hash_map_rehash(SkaStringHashMap* hashMap, SkaStringHashMapNo static void string_hash_map_resize(SkaStringHashMap* hashMap, usize newCapacity); SkaStringHashMap* ska_string_hash_map_create(usize capacity) { - SkaStringHashMap* map = (SkaStringHashMap*)SKA_MEM_ALLOCATE(SkaStringHashMap); + SkaStringHashMap* map = (SkaStringHashMap*)SKA_ALLOC(SkaStringHashMap); map->capacity = capacity; map->size = 0; map->hashFunc = ska_default_hash_string; map->compareFunc = ska_default_compare_string; - map->nodes = (SkaStringHashMapNode**) SKA_MEM_ALLOCATE_SIZE(capacity * sizeof(SkaStringHashMapNode*)); + map->nodes = (SkaStringHashMapNode**) SKA_ALLOC_BYTES(capacity * sizeof(SkaStringHashMapNode*)); memset(map->nodes, 0, capacity * sizeof(SkaStringHashMapNode*)); // TODO: fix return map; } @@ -35,9 +35,9 @@ SkaStringHashMap* ska_string_hash_map_create_default_capacity() { } SkaStringHashMapNode* hash_map_create_node_string(SkaStringHashMap* hashMap, const char* key, const void* value, usize valueSize, SkaStringHashMapNode* next) { - SkaStringHashMapNode* node = (SkaStringHashMapNode*) SKA_MEM_ALLOCATE_SIZE(sizeof(SkaStringHashMapNode)); + SkaStringHashMapNode* node = (SkaStringHashMapNode*) SKA_ALLOC_BYTES(sizeof(SkaStringHashMapNode)); node->key = ska_strdup(key); - node->value = SKA_MEM_ALLOCATE_SIZE(valueSize); + node->value = SKA_ALLOC_BYTES(valueSize); memcpy(node->value, value, valueSize); node->valueSize = valueSize; node->next = next; @@ -56,7 +56,7 @@ bool ska_string_hash_map_destroy(SkaStringHashMap* hashMap) { } } - SKA_MEM_FREE(hashMap); + SKA_FREE(hashMap); return true; } @@ -161,7 +161,7 @@ void string_hash_map_shrink_if_needed(SkaStringHashMap* hashMap) { } void string_hash_map_allocate(SkaStringHashMap* hashMap, usize capacity) { - hashMap->nodes = SKA_MEM_ALLOCATE_SIZE(capacity * sizeof(SkaStringHashMapNode*)); + hashMap->nodes = SKA_ALLOC_BYTES(capacity * sizeof(SkaStringHashMapNode*)); memset(hashMap->nodes, 0, capacity * sizeof(SkaStringHashMapNode*)); hashMap->capacity = capacity; @@ -197,7 +197,7 @@ void string_hash_map_resize(SkaStringHashMap* hashMap, usize newCapacity) { string_hash_map_rehash(hashMap, oldNode, oldCapacity); - SKA_MEM_FREE(oldNode); + SKA_FREE(oldNode); } // Int @@ -213,7 +213,7 @@ int32 ska_string_hash_map_get_int(SkaStringHashMap* hashMap, const char* key) { bool ska_string_hash_map_add_string(SkaStringHashMap* hashMap, const char* key, const char* value) { char* stringVal = ska_strdup(value); bool result = ska_string_hash_map_add(hashMap, key, stringVal, strlen(value) + 1); - SKA_MEM_FREE(stringVal); + SKA_FREE(stringVal); return result; } @@ -289,7 +289,7 @@ void hash_map_destroy_node_string(SkaStringHashMapNode* node) { SKA_ASSERT(node != NULL); SKA_ASSERT(node->value != NULL); SKA_ASSERT(node->key != NULL); - SKA_MEM_FREE(node->key); - SKA_MEM_FREE(node->value); - SKA_MEM_FREE(node); + SKA_FREE(node->key); + SKA_FREE(node->value); + SKA_FREE(node); } diff --git a/seika1/data_structures/queue.c b/seika1/data_structures/queue.c index 711cb4f..e92060d 100644 --- a/seika1/data_structures/queue.c +++ b/seika1/data_structures/queue.c @@ -3,19 +3,19 @@ #include "seika1/memory.h" SkaQueue* ska_queue_create(usize capacity, uint32 invalidValue) { - SkaQueue* queue = SKA_MEM_ALLOCATE(SkaQueue); + SkaQueue* queue = SKA_ALLOC(SkaQueue); queue->capacity = capacity; queue->invalidValue = invalidValue; queue->size = 0; queue->front = 0; queue->rear = (uint32)capacity - 1; - queue->array = (uint32*)SKA_MEM_ALLOCATE_SIZE(queue->capacity * sizeof(uint32)); + queue->array = (uint32*)SKA_ALLOC_BYTES(queue->capacity * sizeof(uint32)); return queue; } void ska_queue_destroy(SkaQueue* queue) { - SKA_MEM_FREE(queue->array); - SKA_MEM_FREE(queue); + SKA_FREE(queue->array); + SKA_FREE(queue); } bool ska_queue_is_full(SkaQueue* queue) { diff --git a/seika1/data_structures/spatial_hash_map.c b/seika1/data_structures/spatial_hash_map.c index b166a74..597302c 100644 --- a/seika1/data_structures/spatial_hash_map.c +++ b/seika1/data_structures/spatial_hash_map.c @@ -25,7 +25,7 @@ static bool collision_result_has_entity(SkaSpatialHashMapCollisionResult* result // Public facing functions SkaSpatialHashMap* ska_spatial_hash_map_create(int32 initialCellSize) { - SkaSpatialHashMap* map = SKA_MEM_ALLOCATE(SkaSpatialHashMap); + SkaSpatialHashMap* map = SKA_ALLOC(SkaSpatialHashMap); map->cellSize = initialCellSize; map->largestObjectSize = initialCellSize; map->gridMap = ska_hash_map_create(sizeof(int32), sizeof(SkaSpatialHashMapGridSpace **), SKA_HASH_MAP_MIN_CAPACITY); @@ -40,18 +40,18 @@ void ska_spatial_hash_map_destroy(SkaSpatialHashMap* hashMap) { SKA_HASH_MAP_FOR_EACH(hashMap->gridMap, iter) { SkaHashMapNode* node = iter.pair; SkaSpatialHashMapGridSpace* gridSpace = (SkaSpatialHashMapGridSpace*) *(SkaSpatialHashMapGridSpace**) node->value; - SKA_MEM_FREE(gridSpace); + SKA_FREE(gridSpace); } ska_hash_map_destroy(hashMap->gridMap); // Grid space Handle Map SKA_HASH_MAP_FOR_EACH(hashMap->objectToGridMap, iter) { SkaHashMapNode* node = iter.pair; SkaSpatialHashMapGridSpacesHandle* handle = (SkaSpatialHashMapGridSpacesHandle*) *(SkaSpatialHashMapGridSpacesHandle**) node->value; - SKA_MEM_FREE(handle); + SKA_FREE(handle); } ska_hash_map_destroy(hashMap->objectToGridMap); // Finally free the hashmap memory - SKA_MEM_FREE(hashMap); + SKA_FREE(hashMap); } // The purpose of this function is to make sure that 'cellSize' is twice as big as the largest object @@ -73,7 +73,7 @@ bool change_cell_size_if_needed(SkaSpatialHashMap* hashMap, SkaRect2* collisionR SkaSpatialHashMapGridSpacesHandle* ska_spatial_hash_map_insert_or_update(SkaSpatialHashMap* hashMap, uint32 entity, SkaRect2* collisionRect) { // Create new object handle if it doesn't exist if (!ska_hash_map_has(hashMap->objectToGridMap, &entity)) { - SkaSpatialHashMapGridSpacesHandle* newHandle = SKA_MEM_ALLOCATE(SkaSpatialHashMapGridSpacesHandle); + SkaSpatialHashMapGridSpacesHandle* newHandle = SKA_ALLOC(SkaSpatialHashMapGridSpacesHandle); newHandle->gridSpaceCount = 0; newHandle->collisionRect = (SkaRect2) { 0.0f, 0.0f, 0.0f, 0.0f @@ -156,7 +156,7 @@ void ska_spatial_hash_map_remove(SkaSpatialHashMap* hashMap, uint32 entity) { hashMap->largestObjectSize = foundLargestObjectSize; } } - SKA_MEM_FREE(objectHandle); + SKA_FREE(objectHandle); } SkaSpatialHashMapGridSpacesHandle* ska_spatial_hash_map_get(SkaSpatialHashMap* hashMap, uint32 entity) { @@ -203,7 +203,7 @@ int32 spatial_hash(SkaSpatialHashMap* hashMap, SkaVector2* position) { SkaSpatialHashMapGridSpace* get_or_create_grid_space(SkaSpatialHashMap* hashMap, int32 positionHash) { if (!ska_hash_map_has(hashMap->gridMap, &positionHash)) { - SkaSpatialHashMapGridSpace* newGridSpace = SKA_MEM_ALLOCATE(SkaSpatialHashMapGridSpace); + SkaSpatialHashMapGridSpace* newGridSpace = SKA_ALLOC(SkaSpatialHashMapGridSpace); newGridSpace->entityCount = 0; ska_hash_map_add(hashMap->gridMap, &positionHash, &newGridSpace); } diff --git a/seika1/memory.h b/seika1/memory.h index cb4f749..7c0773f 100644 --- a/seika1/memory.h +++ b/seika1/memory.h @@ -6,19 +6,19 @@ extern "C" { #include "seika/defines.h" -#define SKA_MEM_ALLOCATE(DataType) \ +#define SKA_ALLOC(DataType) \ (DataType*) ska_mem_allocate(sizeof(DataType)) -#define SKA_MEM_ALLOCATE_ARRAY(DataType, ArraySize) \ -(DataType*) ska_mem_allocate(ArraySize * sizeof(DataType)) +#define SKA_ALLOC_ZEROED(DataType) \ +(DataType*) ska_mem_allocate_zeroed(sizeof(DataType)) -#define SKA_MEM_ALLOCATE_SIZE(Bytes) \ +#define SKA_ALLOC_BYTES(Bytes) \ ska_mem_allocate(Bytes) -#define SKA_MEM_ALLOCATE_SIZE_ZERO(Blocks, Bytes) \ -ska_mem_allocate(Blocks * Bytes) +#define SKA_ALLOC_BYTES_ZEROED(Bytes) \ +ska_mem_allocate_zeroed(Bytes) -#define SKA_MEM_FREE(Memory) \ +#define SKA_FREE(Memory) \ ska_mem_free(Memory) typedef struct SkaMemAllocator { diff --git a/seika1/string.c b/seika1/string.c index 664cee0..a6260b6 100644 --- a/seika1/string.c +++ b/seika1/string.c @@ -11,7 +11,7 @@ char* ska_strdup(const char* string) { const usize string_length = strlen(string) + 1; - char* new_string = (char*)SKA_MEM_ALLOCATE_SIZE(string_length); + char* new_string = (char*)SKA_ALLOC_BYTES(string_length); if (new_string == NULL) { return NULL; @@ -21,7 +21,7 @@ char* ska_strdup(const char* string) { } char* ska_strdup_from_memory(void* data, usize size) { - char* newString = (char*)SKA_MEM_ALLOCATE_SIZE(size + 1); + char* newString = (char*)SKA_ALLOC_BYTES(size + 1); memcpy(newString, data, size); newString[size] = '\0'; return newString; @@ -79,7 +79,7 @@ char* ska_str_to_lower_and_underscore_whitespace(char* str) { unsigned char* ska_str_convert_string_to_unsigned_char(const char* value, usize* outSize) { const usize stringLength = strlen(value); *outSize = stringLength + 1; - unsigned char* returnValue = (unsigned char*)SKA_MEM_ALLOCATE_SIZE(*outSize); + unsigned char* returnValue = (unsigned char*)SKA_ALLOC_BYTES(*outSize); for (usize i = 0; i < stringLength; i++) { returnValue[i] = (unsigned char)value[i]; } @@ -93,7 +93,7 @@ char* ska_str_trim(const char* value, char delimiter) { if (value == NULL) { return NULL; } - newStr = (char*)SKA_MEM_ALLOCATE_SIZE(strlen(value) + 1); + newStr = (char*)SKA_ALLOC_BYTES(strlen(value) + 1); if (newStr == NULL) { return NULL; } @@ -118,7 +118,7 @@ char* ska_str_trim_and_replace(const char* value, char delimiter, const char* re char pathBuffer[SE_TRIM_PATH_BUFFER]; strcpy(pathBuffer, newValue); strcat(pathBuffer, replacementValue); - SKA_MEM_FREE(newValue); + SKA_FREE(newValue); newValue = ska_strdup(pathBuffer); return newValue; #undef SE_TRIM_PATH_BUFFER @@ -146,7 +146,7 @@ char* get_project_archive_name(const char* startingPath) { char pathBuffer[256]; strcpy(pathBuffer, validPath); strcat(pathBuffer, ".zip"); - SKA_MEM_FREE(validPath); + SKA_FREE(validPath); validPath = ska_strdup(pathBuffer); return validPath; } diff --git a/test/test1.c b/test/test1.c index 7135a58..3a02306 100644 --- a/test/test1.c +++ b/test/test1.c @@ -18,11 +18,11 @@ int32 main(int32 argv, char** args) { } void seika_mem_test(void) { - int* testInt = SKA_MEM_ALLOCATE(int); + int* testInt = SKA_ALLOC(int); TEST_ASSERT_NOT_NULL(testInt); *testInt = 5; TEST_ASSERT_EQUAL_INT(5, *testInt); TEST_ASSERT_TRUE(ska_mem_report_leaks()); - SKA_MEM_FREE(testInt); + SKA_FREE(testInt); TEST_ASSERT_FALSE(ska_mem_report_leaks()); } From 667109f830eefe018737f8bedc04a8af7a9f5ee5 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Mon, 14 Oct 2024 10:48:24 -0400 Subject: [PATCH 08/55] More seika1 tests. --- seika1/data_structures/array_list.c | 1 + test/test1.c | 22 ++++++++++++++++++++++ 2 files changed, 23 insertions(+) diff --git a/seika1/data_structures/array_list.c b/seika1/data_structures/array_list.c index 3048aa2..641569b 100644 --- a/seika1/data_structures/array_list.c +++ b/seika1/data_structures/array_list.c @@ -17,6 +17,7 @@ SkaArrayList* ska_array_list_create(usize valueSize, usize initialCapacity) { newList->valueSize = valueSize; newList->capacity = initialCapacity; newList->initialCapacity = initialCapacity; + newList->size = 0; return newList; } diff --git a/test/test1.c b/test/test1.c index 3a02306..cc3fd9b 100644 --- a/test/test1.c +++ b/test/test1.c @@ -2,6 +2,7 @@ #include #include "seika1/memory.h" +#include "seika1/data_structures/array_list.h" #define RESOURCES_PATH "test/resources" #define RESOURCES_PACK_PATH "test/resources/test.pck" @@ -10,10 +11,12 @@ void setUp(void) {} void tearDown(void) {} void seika_mem_test(void); +void seika_array_list_test(void); int32 main(int32 argv, char** args) { UNITY_BEGIN(); RUN_TEST(seika_mem_test); + RUN_TEST(seika_array_list_test); return UNITY_END(); } @@ -26,3 +29,22 @@ void seika_mem_test(void) { SKA_FREE(testInt); TEST_ASSERT_FALSE(ska_mem_report_leaks()); } + +void seika_array_list_test(void) { + int listValues[] = { 8, 2, 3, 5 }; + SkaArrayList* arrayList = ska_array_list_create_default_capacity(sizeof(int)); + TEST_ASSERT_TRUE(ska_array_list_is_empty(arrayList)); + + for (int i = 0; i < 4; i++) { + ska_array_list_push_back(arrayList, &listValues[i]); + } + TEST_ASSERT_FALSE(ska_array_list_is_empty(arrayList)); + int index = 0; + SKA_ARRAY_LIST_FOR_EACH(arrayList, int, i) { + const int value = (int)*(int*)ska_array_list_get(arrayList, index); + TEST_ASSERT_EQUAL_INT(listValues[index], value); + index++; + } + + ska_array_list_destroy(arrayList); +} From 3b2ee8e65c9b9fa7602c87b817e39a3d56a01490 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Wed, 16 Oct 2024 21:16:12 -0400 Subject: [PATCH 09/55] More testing. --- CMakeLists.txt | 46 ++++++++++++++--- Dependencies.cmake | 116 ++++++++++++++++++++++-------------------- seika1/CMakeLists.txt | 24 +++++++-- seika1/defines.h | 27 +++++----- test/test1.c | 10 ++++ 5 files changed, 144 insertions(+), 79 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index ee0eb2b..0587fdc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,6 +6,28 @@ project(seika-framework C) option(IS_CI_BUILD "" OFF) option(SEIKA_STATIC_LIB "Make seika and dependent libs static" OFF) +option(SEIKA_ENABLE_OLD "Will build old seika lib" OFF) +option(SEIKA_ENABLE_1 "Will build new seika lib" ON) + +# Compilation Modes +option(SEIKA_ENABLE_ECS "Will enable ecs" OFF) +option(SEIKA_ENABLE_INPUT "Will enable input" OFF) +option(SEIKA_ENABLE_RENDERING "Will enable rendering" OFF) +option(SEIKA_ENABLE_AUDIO "Will enable audio" OFF) + +# Since everything is enabled by default, we only disable modules +if (!SEIKA_ENABLE_ECS) + add_compile_definitions(SKA_ECS=0) +endif() +if (!SEIKA_ENABLE_INPUT) + add_compile_definitions(SKA_INPUT=0) +endif() +if (!SEIKA_ENABLE_RENDERING) + add_compile_definitions(SKA_RENDERING=0) +endif() +if (!SEIKA_ENABLE_AUDIO) + add_compile_definitions(SKA_AUDIO=0) +endif() set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) @@ -13,8 +35,12 @@ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) #--- Dependencies ---# include(Dependencies.cmake) -add_subdirectory(seika) -add_subdirectory(seika1) +if (SEIKA_ENABLE_OLD) + add_subdirectory(seika) +endif() +if (SEIKA_ENABLE_1) + add_subdirectory(seika1) +endif() if ("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}") set(SK_IS_MAIN TRUE) @@ -23,10 +49,14 @@ else() endif() if (SK_IS_MAIN) - # Create seika test exe - add_executable(seika_test test/test.c) - target_link_libraries(seika_test seika unity) - # Create seika1 test exe - add_executable(seika1_test test/test1.c) - target_link_libraries(seika1_test seika1 unity) + if (SEIKA_ENABLE_OLD) + # Create seika test exe + add_executable(seika_test test/test.c) + target_link_libraries(seika_test seika unity) + endif() + if (SEIKA_ENABLE_1) + # Create seika1 test exe + add_executable(seika1_test test/test1.c) + target_link_libraries(seika1_test seika1 unity) + endif() endif() diff --git a/Dependencies.cmake b/Dependencies.cmake index 88c3871..e18bfa9 100644 --- a/Dependencies.cmake +++ b/Dependencies.cmake @@ -1,34 +1,5 @@ include(FetchContent) -# https://github.com/libsdl-org/SDL -if (NOT TARGET SDL3::SDL3-static) - set(SDL_STATIC ${SEIKA_STATIC_LIB}) - set(SDL_SHARED NOT ${SEIKA_STATIC_LIB}) - - FetchContent_Declare( - SDL_content - GIT_REPOSITORY https://github.com/libsdl-org/SDL.git - GIT_TAG cacac6cc341d5856d1857bdcf7390551eed54865 - ) - FetchContent_MakeAvailable(SDL_content) - - if (SEIKA_STATIC_LIB) - SET(SDL3_LIBRARY SDL3::SDL3-static) - else () - SET(SDL3_LIBRARY SDL3::SDL3) - endif () -endif () - -# https://github.com/Dav1dde/glad -if (NOT TARGET glad) - if (SEIKA_STATIC_LIB) - add_library(glad STATIC thirdparty/glad/glad.c) - else () - add_library(glad thirdparty/glad/glad.c) - endif () - target_include_directories(glad PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/thirdparty") -endif() - # https://github.com/recp/cglm if (NOT TARGET cglm) set(CGLM_STATIC ${SEIKA_STATIC_LIB}) @@ -53,22 +24,6 @@ if (NOT TARGET kuba_zip) FetchContent_MakeAvailable(kuba_zip_content) endif() -# https://github.com/mackron/miniaudio -if (NOT TARGET miniaudio) - add_library(miniaudio INTERFACE thirdparty/miniaudio/miniaudio.h) - target_include_directories(miniaudio INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/miniaudio") -endif() - -# https://github.com/nothings/stb -if (NOT TARGET stb_image) - if (SEIKA_STATIC_LIB) - add_library(stb_image STATIC thirdparty/stb_image/stb_image.c) - else () - add_library(stb_image thirdparty/stb_image/stb_image.c) - endif () - target_include_directories(stb_image PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/thirdparty") -endif() - # https://github.com/ThrowTheSwitch/Unity if (NOT TARGET unity) add_definitions(-DUNITY_INCLUDE_DOUBLE) @@ -81,16 +36,67 @@ if (NOT TARGET unity) FetchContent_MakeAvailable(unity_content) endif() -# https://github.com/freetype/freetype -if (NOT TARGET freetype) - if (NOT SEIKA_STATIC_LIB) - set(BUILD_SHARED_LIBS ON) +if (SEIKA_ENABLE_INPUT) + # https://github.com/libsdl-org/SDL + if (NOT TARGET SDL3::SDL3-static) + set(SDL_STATIC ${SEIKA_STATIC_LIB}) + set(SDL_SHARED NOT ${SEIKA_STATIC_LIB}) + + FetchContent_Declare( + SDL_content + GIT_REPOSITORY https://github.com/libsdl-org/SDL.git + GIT_TAG cacac6cc341d5856d1857bdcf7390551eed54865 + ) + FetchContent_MakeAvailable(SDL_content) + + if (SEIKA_STATIC_LIB) + SET(SDL3_LIBRARY SDL3::SDL3-static) + else () + SET(SDL3_LIBRARY SDL3::SDL3) + endif () endif () +endif() - FetchContent_Declare( - freetype_content - GIT_REPOSITORY https://github.com/freetype/freetype.git - GIT_TAG VER-2-13-2 - ) - FetchContent_MakeAvailable(freetype_content) +if (SEIKA_ENABLE_RENDERING) + # https://github.com/Dav1dde/glad + if (NOT TARGET glad) + if (SEIKA_STATIC_LIB) + add_library(glad STATIC thirdparty/glad/glad.c) + else () + add_library(glad thirdparty/glad/glad.c) + endif () + target_include_directories(glad PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/thirdparty") + endif() + + # https://github.com/nothings/stb + if (NOT TARGET stb_image) + if (SEIKA_STATIC_LIB) + add_library(stb_image STATIC thirdparty/stb_image/stb_image.c) + else () + add_library(stb_image thirdparty/stb_image/stb_image.c) + endif () + target_include_directories(stb_image PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/thirdparty") + endif() + + # https://github.com/freetype/freetype + if (NOT TARGET freetype) + if (NOT SEIKA_STATIC_LIB) + set(BUILD_SHARED_LIBS ON) + endif () + + FetchContent_Declare( + freetype_content + GIT_REPOSITORY https://github.com/freetype/freetype.git + GIT_TAG VER-2-13-2 + ) + FetchContent_MakeAvailable(freetype_content) + endif() +endif() + +if (SEIKA_ENABLE_AUDIO) + # https://github.com/mackron/miniaudio + if (NOT TARGET miniaudio) + add_library(miniaudio INTERFACE thirdparty/miniaudio/miniaudio.h) + target_include_directories(miniaudio INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/miniaudio") + endif() endif() diff --git a/seika1/CMakeLists.txt b/seika1/CMakeLists.txt index 81d54de..dec5c19 100644 --- a/seika1/CMakeLists.txt +++ b/seika1/CMakeLists.txt @@ -18,15 +18,31 @@ file(GLOB_RECURSE SEIKA_SRC ./*.c ./*.h) add_library(${PROJECT_NAME} STATIC ${SEIKA_SRC}) target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../) +set(LIBS_TO_LINK "") + +if (SEIKA_ENABLE_RENDERING) + list(APPEND LIBS_TO_LINK glad stb_image freetype) +endif() + +if (SEIKA_ENABLE_AUDIO) + list(APPEND LIBS_TO_LINK miniaudio) +endif() + +if (SEIKA_ENABLE_INPUT) + list(APPEND LIBS_TO_LINK ${SDL3_LIBRARY}) +endif() + #--- Link ---# if (CMAKE_C_COMPILER_ID STREQUAL "MSVC") - target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio ${SDL3_LIBRARY} freetype Ws2_32) + list(APPEND LIBS_TO_LINK Ws2_32) elseif (WIN32) - target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio -lmingw32 -static-libgcc ${SDL3_LIBRARY} freetype -lws2_32) + list(APPEND LIBS_TO_LINK -lmingw32 -static-libgcc -lws2_32) elseif (APPLE) - target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio -Xlinker ${SDL3_LIBRARY} freetype m) + list(APPEND LIBS_TO_LINK m) else () - target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio -static-libgcc -Xlinker -export-dynamic ${SDL3_LIBRARY} freetype m) + list(APPEND LIBS_TO_LINK -static-libgcc -Xlinker -export-dynamic m) endif () +target_link_libraries(${PROJECT_NAME} PUBLIC cglm zip ${LIBS_TO_LINK}) + target_compile_options(${PROJECT_NAME} PUBLIC ${flags}) diff --git a/seika1/defines.h b/seika1/defines.h index 92d8ff0..dca0060 100644 --- a/seika1/defines.h +++ b/seika1/defines.h @@ -12,18 +12,21 @@ extern "C" { // Compilation modes -#ifndef SKA_RENDERING_MODULE -#define SKA_RENDERING_MODULE 1 -#endif - -#define SKA_INCLUDE_RENDERING 1 -#define SKA_INCLUDE_THREAD 1 -#define SKA_INCLUDE_NETWORKING 1 -#define SKA_INCLUDE_DATA_STRUCTURES 1 -#define SKA_INCLUDE_ASSET 1 -#define SKA_INCLUDE_AUDIO 1 -#define SKA_INCLUDE_ECS 1 -#define SKA_INCLUDE_MATH 1 +#ifndef SKA_ECS +#define SKA_ECS 1 +#endif + +#ifndef SKA_INPUT +#define SKA_INPUT 1 +#endif + +#ifndef SKA_RENDERING +#define SKA_RENDERING 1 +#endif + +#ifndef SKA_AUDIO +#define SKA_AUDIO 1 +#endif typedef size_t usize; diff --git a/test/test1.c b/test/test1.c index cc3fd9b..325cdf3 100644 --- a/test/test1.c +++ b/test/test1.c @@ -46,5 +46,15 @@ void seika_array_list_test(void) { index++; } + ska_array_list_remove_by_index(arrayList, 1); + int oneValue = (int)*(int*)ska_array_list_get(arrayList, 1); + TEST_ASSERT_EQUAL_INT(3, oneValue); + + ska_array_list_remove(arrayList, &(int){3}); + oneValue = (int)*(int*)ska_array_list_get(arrayList, 1); + TEST_ASSERT_EQUAL_INT(5, oneValue); + + ska_array_list_clear(arrayList); + TEST_ASSERT_TRUE(ska_array_list_is_empty(arrayList)); ska_array_list_destroy(arrayList); } From 9428c63cbeb4933dc60acfa9823c0f93232ff0d2 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Wed, 16 Oct 2024 22:45:32 -0400 Subject: [PATCH 10/55] Test. --- seika1/data_structures/queue.h | 6 + seika1/data_structures/queue_template.h | 80 ++++++ seika1/ecs/component.c | 191 ++++++++++++++ seika1/ecs/component.h | 54 ++++ seika1/ecs/ec_system.c | 331 ++++++++++++++++++++++++ seika1/ecs/ec_system.h | 110 ++++++++ seika1/ecs/ecs.c | 13 + seika1/ecs/ecs.h | 6 + seika1/ecs/entity.c | 43 +++ seika1/ecs/entity.h | 24 ++ test/test1.c | 4 + 11 files changed, 862 insertions(+) create mode 100644 seika1/data_structures/queue_template.h create mode 100644 seika1/ecs/component.c create mode 100644 seika1/ecs/component.h create mode 100644 seika1/ecs/ec_system.c create mode 100644 seika1/ecs/ec_system.h create mode 100644 seika1/ecs/ecs.c create mode 100644 seika1/ecs/ecs.h create mode 100644 seika1/ecs/entity.c create mode 100644 seika1/ecs/entity.h diff --git a/seika1/data_structures/queue.h b/seika1/data_structures/queue.h index 0c08018..85ec390 100644 --- a/seika1/data_structures/queue.h +++ b/seika1/data_structures/queue.h @@ -1,5 +1,11 @@ #pragma once +// #define SKA_QUEUE_TEMPLATE uint32 +// #include "queue_template.h" +// #define SKA_QUEUE_TEMPLATE int32 +// #include "queue_template.h" +// #undef SKA_QUEUE_TEMPLATE + #include "seika1/defines.h" // TODO: If other types are needed, create a macro to simplify queues by type diff --git a/seika1/data_structures/queue_template.h b/seika1/data_structures/queue_template.h new file mode 100644 index 0000000..9346381 --- /dev/null +++ b/seika1/data_structures/queue_template.h @@ -0,0 +1,80 @@ +// Test template + +#ifndef SKA_QUEUE_TEMPLATE +#error "SKA_QUEUE_TEMPLATE must be defined before including queue_template.h" +#endif + +#include "seika1/defines.h" +#include "seika1/memory.h" + +#define SKA_QUEUE_T(Name) SkaQueue_##Name +#define SKA_QUEUE_FUNC(Name, Suffix) ska_queue_##Name##_##Suffix + +// Struct definition +typedef struct SKA_QUEUE_T(SKA_QUEUE_TEMPLATE) { + SKA_QUEUE_TEMPLATE front, rear, size, invalidValue; + usize capacity; + SKA_QUEUE_TEMPLATE* array; +} SKA_QUEUE_T(SKA_QUEUE_TEMPLATE); + +// Function definitions +SKA_QUEUE_T(SKA_QUEUE_TEMPLATE)* SKA_QUEUE_FUNC(SKA_QUEUE_TEMPLATE, create)(usize capacity, SKA_QUEUE_TEMPLATE invalidValue) { + SKA_QUEUE_T(SKA_QUEUE_TEMPLATE)* queue = SKA_ALLOC(SKA_QUEUE_T(SKA_QUEUE_TEMPLATE)); + queue->capacity = capacity; + queue->invalidValue = invalidValue; + queue->size = 0; + queue->front = 0; + queue->rear = capacity - 1; + queue->array = (SKA_QUEUE_TEMPLATE*)SKA_ALLOC_BYTES(queue->capacity * sizeof(SKA_QUEUE_TEMPLATE)); + return queue; +} + +void SKA_QUEUE_FUNC(SKA_QUEUE_TEMPLATE, destroy)(SKA_QUEUE_T(SKA_QUEUE_TEMPLATE)* queue) { + SKA_FREE(queue->array); + SKA_FREE(queue); +} + +bool SKA_QUEUE_FUNC(SKA_QUEUE_TEMPLATE, is_full)(SKA_QUEUE_T(SKA_QUEUE_TEMPLATE)* queue) { + return queue->size == queue->capacity; +} + +bool SKA_QUEUE_FUNC(SKA_QUEUE_TEMPLATE, is_empty)(SKA_QUEUE_T(SKA_QUEUE_TEMPLATE)* queue) { + return queue->size == 0; +} + +void SKA_QUEUE_FUNC(SKA_QUEUE_TEMPLATE, enqueue)(SKA_QUEUE_T(SKA_QUEUE_TEMPLATE)* queue, SKA_QUEUE_TEMPLATE item) { + if (SKA_QUEUE_FUNC(SKA_QUEUE_TEMPLATE, is_full)(queue)) { + return; + } + queue->rear = (queue->rear + 1) % queue->capacity; + queue->array[queue->rear] = item; + queue->size++; +} + +SKA_QUEUE_TEMPLATE SKA_QUEUE_FUNC(SKA_QUEUE_TEMPLATE, dequeue)(SKA_QUEUE_T(SKA_QUEUE_TEMPLATE)* queue) { + if (SKA_QUEUE_FUNC(SKA_QUEUE_TEMPLATE, is_empty)(queue)) { + return queue->invalidValue; + } + SKA_QUEUE_TEMPLATE item = queue->array[queue->front]; + queue->front = (queue->front + 1) % queue->capacity; + queue->size--; + return item; +} + +SKA_QUEUE_TEMPLATE SKA_QUEUE_FUNC(SKA_QUEUE_TEMPLATE, front)(SKA_QUEUE_T(SKA_QUEUE_TEMPLATE)* queue) { + if (SKA_QUEUE_FUNC(SKA_QUEUE_TEMPLATE, is_empty)(queue)) { + return queue->invalidValue; + } + return queue->array[queue->front]; +} + +SKA_QUEUE_TEMPLATE SKA_QUEUE_FUNC(SKA_QUEUE_TEMPLATE, rear)(SKA_QUEUE_T(SKA_QUEUE_TEMPLATE)* queue) { + if (SKA_QUEUE_FUNC(SKA_QUEUE_TEMPLATE, is_empty)(queue)) { + return queue->invalidValue; + } + return queue->array[queue->rear]; +} + +#undef SKA_QUEUE_T +#undef SKA_QUEUE_FUNC +#undef SKA_QUEUE_TEMPLATE diff --git a/seika1/ecs/component.c b/seika1/ecs/component.c new file mode 100644 index 0000000..0aee34a --- /dev/null +++ b/seika1/ecs/component.c @@ -0,0 +1,191 @@ +#include "component.h" + +#include + +#include "seika/string.h" +#include "seika/memory.h" +#include "seika/assert.h" +#include "seika/data_structures/hash_map_string.h" + +//--- Component ---// +static SkaComponentIndex globalComponentIndex = 0; +static SkaStringHashMap* componentNameToTypeMap = NULL; + +const SkaComponentTypeInfo* ska_ecs_component_register_type(const char* name, usize componentSize) { + SKA_ASSERT_FMT(globalComponentIndex + 1 < SKA_ECS_MAX_COMPONENTS, "Over the maximum allowed components which are '%d'", SKA_ECS_MAX_COMPONENTS); + // Check if component already exists and return that index if it does + const SkaComponentTypeInfo* typeInfo = (SkaComponentTypeInfo*)ska_string_hash_map_find(componentNameToTypeMap, name); + if (typeInfo) { + return typeInfo; + } + // Add new type info for component + const SkaComponentIndex newTypeIndex = globalComponentIndex++; + const SkaComponentTypeInfo newTypeInfo = { + .name = ska_strdup(name), + .type = 1 << newTypeIndex, // Bitshift for flag assignment + .index = newTypeIndex, + .size = componentSize + }; + ska_string_hash_map_add(componentNameToTypeMap, name, &newTypeInfo, sizeof(SkaComponentTypeInfo)); + return ska_ecs_component_get_type_info(name, componentSize); +} + +const SkaComponentTypeInfo* ska_ecs_component_get_type_info(const char* name, usize componentSize) { + const SkaComponentTypeInfo* typeInfo = (SkaComponentTypeInfo*)ska_string_hash_map_find(componentNameToTypeMap, name); + SKA_ASSERT(typeInfo); + SKA_ASSERT(typeInfo->size == componentSize); + return typeInfo; +} + +const SkaComponentTypeInfo* ska_ecs_component_find_type_info(const char* name) { + const SkaComponentTypeInfo* typeInfo = (SkaComponentTypeInfo*)ska_string_hash_map_find(componentNameToTypeMap, name); + return typeInfo; +} + +SkaComponentType ska_ecs_component_get_type_flag(const char* name, usize componentSize) { + const SkaComponentTypeInfo* typeInfo = ska_ecs_component_get_type_info(name, componentSize); + return typeInfo->type; +} + +//--- Component Array ---// +typedef struct ComponentArray { + void* components[SKA_ECS_MAX_COMPONENTS]; +} ComponentArray; + +static ComponentArray* component_array_create() { + ComponentArray* componentArray = SKA_MEM_ALLOCATE(ComponentArray); + for (unsigned int i = 0; i < SKA_ECS_MAX_COMPONENTS; i++) { + componentArray->components[i] = NULL; + } + return componentArray; +} + +static void component_array_initialize(ComponentArray* componentArray) { + for (unsigned int i = 0; i < SKA_ECS_MAX_COMPONENTS; i++) { + componentArray->components[i] = NULL; + } +} + +static bool component_array_has_component(ComponentArray* componentArray, SkaComponentIndex index) { + return componentArray->components[index] == NULL ? false : true; +} + +static void* component_array_get_component(ComponentArray* componentArray, SkaComponentIndex index) { + return componentArray->components[index]; +} + +static void component_array_set_component(ComponentArray* componentArray, SkaComponentIndex index, void* component) { + componentArray->components[index] = component; +} + +static void component_array_remove_component(ComponentArray* componentArray, SkaComponentIndex index) { + SKA_MEM_FREE(componentArray->components[index]); + componentArray->components[index] = NULL; +} + +static void component_array_remove_all_components(ComponentArray* componentArray) { + for (usize i = 0; i < SKA_ECS_MAX_COMPONENTS; i++) { + component_array_remove_component(componentArray, (SkaComponentIndex)i); + } +} + +//--- Component Manager ---// +typedef struct ComponentManager { + ComponentArray entityComponentArrays[SKA_MAX_ENTITIES]; + SkaComponentType entityComponentSignatures[SKA_MAX_ENTITIES]; +} ComponentManager; + +static ComponentManager* componentManager = NULL; + +static SkaComponentType component_manager_translate_index_to_type(SkaComponentIndex index); + +void ska_ecs_component_manager_initialize() { + SKA_ASSERT(componentNameToTypeMap == NULL); + componentNameToTypeMap = ska_string_hash_map_create_default_capacity(); + + SKA_ASSERT_FMT(componentManager == NULL, "Component Manager is not NULL when trying to initialize"); + componentManager = SKA_MEM_ALLOCATE(ComponentManager); +} + +// Assumes component data was already deleted previously +void ska_ecs_component_manager_finalize() { + SKA_ASSERT(componentNameToTypeMap != NULL); + SKA_STRING_HASH_MAP_FOR_EACH(componentNameToTypeMap, iter) { + SkaStringHashMapNode* node = iter.pair; + SkaComponentTypeInfo* typeInfo = (SkaComponentTypeInfo*)node->value; + if (typeInfo) { + SKA_MEM_FREE(typeInfo->name); + } + } + ska_string_hash_map_destroy(componentNameToTypeMap); + componentNameToTypeMap = NULL; + globalComponentIndex = 0; + + SKA_ASSERT_FMT(componentManager != NULL, "Component Manager is NULL when trying to finalize..."); + SKA_MEM_FREE(componentManager); + componentManager = NULL; +} + +void* ska_ecs_component_manager_get_component(SkaEntity entity, SkaComponentIndex index) { + void* component = component_array_get_component(&componentManager->entityComponentArrays[entity], index); + SKA_ASSERT_FMT(component != NULL, "Entity '%d' doesn't have '%s' component!", entity, ska_ecs_component_get_component_data_index_string(index)); + return component; +} + +void* ska_ecs_component_manager_get_component_unchecked(SkaEntity entity, SkaComponentIndex index) { + return component_array_get_component(&componentManager->entityComponentArrays[entity], index); +} + +void ska_ecs_component_manager_set_component(SkaEntity entity, SkaComponentIndex index, void* component) { + component_array_set_component(&componentManager->entityComponentArrays[entity], index, component); + // Update signature + SkaComponentType componentSignature = ska_ecs_component_manager_get_component_signature(entity); + componentSignature |= component_manager_translate_index_to_type(index); + ska_ecs_component_manager_set_component_signature(entity, componentSignature); +} + +void ska_ecs_component_manager_remove_component(SkaEntity entity, SkaComponentIndex index) { + SkaComponentType componentSignature = ska_ecs_component_manager_get_component_signature(entity); + componentSignature &= component_manager_translate_index_to_type(index); + ska_ecs_component_manager_set_component_signature(entity, componentSignature); + component_array_remove_component(&componentManager->entityComponentArrays[entity], index); +} + +void ska_ecs_component_manager_remove_all_components(SkaEntity entity) { + component_array_remove_all_components(&componentManager->entityComponentArrays[entity]); + ska_ecs_component_manager_set_component_signature(entity, SKA_ECS_COMPONENT_TYPE_NONE); +} + +bool ska_ecs_component_manager_has_component(SkaEntity entity, SkaComponentIndex index) { + return component_array_has_component(&componentManager->entityComponentArrays[entity], index); +} + +void ska_ecs_component_manager_set_component_signature(SkaEntity entity, SkaComponentType componentTypeSignature) { + componentManager->entityComponentSignatures[entity] = componentTypeSignature; +} + +SkaComponentType ska_ecs_component_manager_get_component_signature(SkaEntity entity) { + return componentManager->entityComponentSignatures[entity]; +} + +SkaComponentType component_manager_translate_index_to_type(SkaComponentIndex index) { + SKA_STRING_HASH_MAP_FOR_EACH(componentNameToTypeMap, iter) { + SkaStringHashMapNode* node = iter.pair; + const SkaComponentTypeInfo* typeInfo = (SkaComponentTypeInfo*)node->value; + if (typeInfo->index == index) { + return typeInfo->type; + } + } + return SKA_ECS_COMPONENT_TYPE_NONE; +} + +const char* ska_ecs_component_get_component_data_index_string(SkaComponentIndex index) { + SKA_STRING_HASH_MAP_FOR_EACH(componentNameToTypeMap, iter) { + SkaStringHashMapNode* node = iter.pair; + const SkaComponentTypeInfo* typeInfo = (SkaComponentTypeInfo*)node->value; + if (typeInfo->index == index) { + return typeInfo->name; + } + } + return "INVALID"; +} diff --git a/seika1/ecs/component.h b/seika1/ecs/component.h new file mode 100644 index 0000000..5057b84 --- /dev/null +++ b/seika1/ecs/component.h @@ -0,0 +1,54 @@ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "seika1/defines.h" + +#include "entity.h" + +#define SKA_ECS_MAX_COMPONENTS 32 +#define SKA_ECS_COMPONENT_TYPE_NONE ((SkaComponentType)0) + +#define SKA_ECS_REGISTER_COMPONENT(ComponentType) \ +ska_ecs_component_register_type(#ComponentType, sizeof(ComponentType)) + +#define SKA_ECS_COMPONENT_TYPE_INFO(ComponentType) \ +ska_ecs_component_get_type_info(#ComponentType, sizeof(ComponentType)) + +#define SKA_ECS_COMPONENT_TYPE_FLAG(ComponentType) \ +ska_ecs_component_get_type_flag(#ComponentType, sizeof(ComponentType)) + +typedef uint32 SkaComponentIndex; +typedef uint32 SkaComponentType; + +typedef struct SkaComponentTypeInfo { + char* name; + SkaComponentType type; + SkaComponentIndex index; + usize size; +} SkaComponentTypeInfo; + +const SkaComponentTypeInfo* ska_ecs_component_register_type(const char* name, usize componentSize); +const SkaComponentTypeInfo* ska_ecs_component_get_type_info(const char* name, usize componentSize); +const SkaComponentTypeInfo* ska_ecs_component_find_type_info(const char* name); +SkaComponentType ska_ecs_component_get_type_flag(const char* name, usize componentSize); + +// --- Component Manager --- // +void ska_ecs_component_manager_initialize(); +void ska_ecs_component_manager_finalize(); +void* ska_ecs_component_manager_get_component(SkaEntity entity, SkaComponentIndex index); +void* ska_ecs_component_manager_get_component_unchecked(SkaEntity entity, SkaComponentIndex index); // No check, will probably consolidate later... +void ska_ecs_component_manager_set_component(SkaEntity entity, SkaComponentIndex index, void* component); +void ska_ecs_component_manager_remove_component(SkaEntity entity, SkaComponentIndex index); +void ska_ecs_component_manager_remove_all_components(SkaEntity entity); +bool ska_ecs_component_manager_has_component(SkaEntity entity, SkaComponentIndex index); +void ska_ecs_component_manager_set_component_signature(SkaEntity entity, SkaComponentType componentTypeSignature); +SkaComponentType ska_ecs_component_manager_get_component_signature(SkaEntity entity); + +const char* ska_ecs_component_get_component_data_index_string(SkaComponentIndex index); + +#ifdef __cplusplus +} +#endif diff --git a/seika1/ecs/ec_system.c b/seika1/ecs/ec_system.c new file mode 100644 index 0000000..f5afd9b --- /dev/null +++ b/seika1/ecs/ec_system.c @@ -0,0 +1,331 @@ +#include "ec_system.h" + +#include + +#include "seika/string.h" +#include "seika/flag_utils.h" +#include "seika/logger.h" +#include "seika/memory.h" +#include "seika/assert.h" + +//--- EC System Manager ---// +#define MAX_ENTITY_SYSTEMS_PER_HOOK 12 + +typedef struct EntitySystemData { + usize entity_systems_count; + usize on_entity_start_systems_count; + usize on_entity_end_systems_count; + usize on_entity_entered_scene_systems_count; + usize render_systems_count; + usize pre_update_all_systems_count; + usize post_update_all_systems_count; + usize update_systems_count; + usize fixed_update_systems_count; + usize network_callback_systems_count; + SkaECSSystem* entity_systems[SKA_ECS_MAX_COMPONENTS]; + SkaECSSystem* on_entity_start_systems[MAX_ENTITY_SYSTEMS_PER_HOOK]; + SkaECSSystem* on_entity_end_systems[MAX_ENTITY_SYSTEMS_PER_HOOK]; + SkaECSSystem* on_entity_entered_scene_systems[MAX_ENTITY_SYSTEMS_PER_HOOK]; + SkaECSSystem* render_systems[MAX_ENTITY_SYSTEMS_PER_HOOK]; + SkaECSSystem* update_systems[MAX_ENTITY_SYSTEMS_PER_HOOK]; + SkaECSSystem* pre_update_all_systems[MAX_ENTITY_SYSTEMS_PER_HOOK]; + SkaECSSystem* post_update_all_systems[MAX_ENTITY_SYSTEMS_PER_HOOK]; + SkaECSSystem* fixed_update_systems[MAX_ENTITY_SYSTEMS_PER_HOOK]; + SkaECSSystem* network_callback_systems[MAX_ENTITY_SYSTEMS_PER_HOOK]; +} EntitySystemData; + +void ska_ecs_system_insert_entity_into_system(SkaEntity entity, SkaECSSystem* system); +void ska_ecs_system_remove_entity_from_system(SkaEntity entity, SkaECSSystem* system); + +static EntitySystemData entitySystemData; + +void ska_ecs_system_initialize() { + // Initialize system data to 0 + entitySystemData = (EntitySystemData){0}; +} + +void ska_ecs_system_finalize() { + for (usize i = 0; i < entitySystemData.entity_systems_count; i++) { + ska_ecs_system_destroy(entitySystemData.entity_systems[i]); + entitySystemData.entity_systems[i] = NULL; + } +} + +SkaECSSystem* ska_ecs_system_create(const char* systemName) { + SkaECSSystem* newSystem = SKA_MEM_ALLOCATE(SkaECSSystem); + newSystem->name = ska_strdup(systemName); + return newSystem; +} + +SkaECSSystem* ska_ecs_system_create_from_template(SkaECSSystemTemplate* systemTemplate) { + SkaECSSystem* newSystem = SKA_MEM_ALLOCATE(SkaECSSystem); + newSystem->name = ska_strdup(systemTemplate->name); + newSystem->on_ec_system_register = systemTemplate->on_ec_system_register; + newSystem->on_ec_system_destroy = systemTemplate->on_ec_system_destroy; + newSystem->on_entity_registered_func = systemTemplate->on_entity_registered_func; + newSystem->on_entity_start_func = systemTemplate->on_entity_start_func; + newSystem->on_entity_end_func = systemTemplate->on_entity_end_func; + newSystem->on_entity_unregistered_func = systemTemplate->on_entity_unregistered_func; + newSystem->on_entity_entered_scene_func = systemTemplate->on_entity_entered_scene_func; + newSystem->render_func = systemTemplate->render_func; + newSystem->pre_update_all_func = systemTemplate->pre_update_all_func; + newSystem->post_update_all_func = systemTemplate->post_update_all_func; + newSystem->update_func = systemTemplate->update_func; + newSystem->fixed_update_func = systemTemplate->fixed_update_func; + newSystem->network_callback_func = systemTemplate->network_callback_func; + return newSystem; +} + +SkaECSSystemTemplate ska_ecs_system_create_default_template(const char* systemName) { + return (SkaECSSystemTemplate){ + .name = systemName, .on_ec_system_register = NULL, .on_ec_system_destroy = NULL, .on_entity_registered_func = NULL, .on_entity_start_func = NULL, .on_entity_end_func = NULL, + .on_entity_unregistered_func = NULL, .on_entity_entered_scene_func = NULL, .render_func = NULL, .pre_update_all_func = NULL, .post_update_all_func = NULL, + .update_func = NULL, .fixed_update_func = NULL, .network_callback_func = NULL + }; +} + +static SkaECSSystem* update_system_with_type_signature_string(SkaECSSystem* system, const char* signatures) { + // Take signature string, create flags, and add to system's component signature + static char typeNameBuffer[256]; + char* word = typeNameBuffer; + char* start = word; + for (const char* src = signatures; *src != '\0'; ++src) { + // Skip commas and whitespace + if (*src == ',') { + *word = '\0'; + const SkaComponentTypeInfo* typeInfo = ska_ecs_component_find_type_info(typeNameBuffer); + SKA_ASSERT_FMT(typeInfo, "Unable to get type info for '%s'", typeNameBuffer); + system->component_signature |= typeInfo->type; + word = start; + continue; + } else if (*src == ' ') { + continue; + } + *word++ = *src; + } + + *word = '\0'; + const SkaComponentTypeInfo* typeInfo = ska_ecs_component_find_type_info(typeNameBuffer); + SKA_ASSERT_FMT(typeInfo, "Unable to get type info for '%s'", typeNameBuffer); + system->component_signature |= typeInfo->type; + return system; +} + +SkaECSSystem* ska_ecs_system_create_with_signature_string(const char* systemName, const char* signatures) { + SkaECSSystem* newSystem = ska_ecs_system_create(systemName); + update_system_with_type_signature_string(newSystem, signatures); + return newSystem; +} + +SkaECSSystem* ska_ecs_system_create_from_template_with_signature_string(SkaECSSystemTemplate* systemTemplate, const char* signatures) { + SkaECSSystem* newSystem = ska_ecs_system_create_from_template(systemTemplate); + update_system_with_type_signature_string(newSystem, signatures); + return newSystem; +} + +void ska_ecs_system_destroy(SkaECSSystem* entitySystem) { + if (entitySystem->on_ec_system_destroy) { + entitySystem->on_ec_system_destroy(entitySystem); + } + SKA_MEM_FREE(entitySystem); +} + +void ska_ecs_system_register(SkaECSSystem* system) { + SKA_ASSERT_FMT(system != NULL, "Passed in system is NULL!"); + SKA_ASSERT_FMT(entitySystemData.entity_systems_count + 1 < SKA_ECS_MAX_COMPONENTS, "At system limit of '%d'", SKA_ECS_MAX_COMPONENTS); + entitySystemData.entity_systems[entitySystemData.entity_systems_count++] = system; + if (system->on_ec_system_register != NULL) { + system->on_ec_system_register(system); + } + if (system->on_entity_start_func != NULL) { + SKA_ASSERT_FMT(entitySystemData.on_entity_start_systems_count + 1 < MAX_ENTITY_SYSTEMS_PER_HOOK, "At system 'on_entity_start_func' limit of '%d'", MAX_ENTITY_SYSTEMS_PER_HOOK); + entitySystemData.on_entity_start_systems[entitySystemData.on_entity_start_systems_count++] = system; + } + if (system->on_entity_end_func != NULL) { + SKA_ASSERT_FMT(entitySystemData.on_entity_end_systems_count + 1 < MAX_ENTITY_SYSTEMS_PER_HOOK, "At system 'on_entity_end_func' limit of '%d'", MAX_ENTITY_SYSTEMS_PER_HOOK); + entitySystemData.on_entity_end_systems[entitySystemData.on_entity_end_systems_count++] = system; + } + if (system->on_entity_entered_scene_func != NULL) { + SKA_ASSERT_FMT(entitySystemData.on_entity_entered_scene_systems_count + 1 < MAX_ENTITY_SYSTEMS_PER_HOOK, "At system 'on_entity_entered_scene_func' limit of '%d'", MAX_ENTITY_SYSTEMS_PER_HOOK); + entitySystemData.on_entity_entered_scene_systems[entitySystemData.on_entity_entered_scene_systems_count++] = system; + } + if (system->render_func != NULL) { + SKA_ASSERT_FMT(entitySystemData.render_systems_count + 1 < MAX_ENTITY_SYSTEMS_PER_HOOK, "At system 'render_func' limit of '%d'", MAX_ENTITY_SYSTEMS_PER_HOOK); + entitySystemData.render_systems[entitySystemData.render_systems_count++] = system; + } + if (system->pre_update_all_func != NULL) { + SKA_ASSERT_FMT(entitySystemData.pre_update_all_systems_count + 1 < MAX_ENTITY_SYSTEMS_PER_HOOK, "At system 'pre_update_all_func' limit of '%d'", MAX_ENTITY_SYSTEMS_PER_HOOK); + entitySystemData.pre_update_all_systems[entitySystemData.pre_update_all_systems_count++] = system; + } + if (system->post_update_all_func != NULL) { + SKA_ASSERT_FMT(entitySystemData.post_update_all_systems_count + 1 < MAX_ENTITY_SYSTEMS_PER_HOOK, "At system 'post_update_all_func' limit of '%d'", MAX_ENTITY_SYSTEMS_PER_HOOK); + entitySystemData.post_update_all_systems[entitySystemData.post_update_all_systems_count++] = system; + } + if (system->update_func != NULL) { + SKA_ASSERT_FMT(entitySystemData.update_systems_count + 1 < MAX_ENTITY_SYSTEMS_PER_HOOK, "At system 'update_func' limit of '%d'", MAX_ENTITY_SYSTEMS_PER_HOOK); + entitySystemData.update_systems[entitySystemData.update_systems_count++] = system; + } + if (system->fixed_update_func != NULL) { + SKA_ASSERT_FMT(entitySystemData.fixed_update_systems_count + 1 < MAX_ENTITY_SYSTEMS_PER_HOOK, "At system 'fixed_update_func' limit of '%d'", MAX_ENTITY_SYSTEMS_PER_HOOK); + entitySystemData.fixed_update_systems[entitySystemData.fixed_update_systems_count++] = system; + } + if (system->network_callback_func != NULL) { + SKA_ASSERT_FMT(entitySystemData.network_callback_systems_count + 1 < MAX_ENTITY_SYSTEMS_PER_HOOK, "At system 'network_callback_func' limit of '%d'", MAX_ENTITY_SYSTEMS_PER_HOOK); + entitySystemData.network_callback_systems[entitySystemData.network_callback_systems_count++] = system; + } +} + +void ska_ecs_system_update_entity_signature_with_systems(SkaEntity entity) { + const SkaComponentType entityComponentSignature = ska_ecs_component_manager_get_component_signature(entity); + for (usize i = 0; i < entitySystemData.entity_systems_count; i++) { + if (SKA_FLAG_CONTAINS(entityComponentSignature, entitySystemData.entity_systems[i]->component_signature)) { + ska_ecs_system_insert_entity_into_system(entity, entitySystemData.entity_systems[i]); + } else { + ska_ecs_system_remove_entity_from_system(entity, entitySystemData.entity_systems[i]); + } + } +} + +void ska_ecs_system_event_entity_start(SkaEntity entity) { + const SkaComponentType entityComponentSignature = ska_ecs_component_manager_get_component_signature(entity); + for (usize i = 0; i < entitySystemData.on_entity_start_systems_count; i++) { + SkaECSSystem* ecsSystem = entitySystemData.on_entity_start_systems[i]; + if (SKA_FLAG_CONTAINS(entityComponentSignature, ecsSystem->component_signature)) { + ecsSystem->on_entity_start_func(ecsSystem, entity); + } + } +} + +void ska_ecs_system_event_entity_end(SkaEntity entity) { + // Notify scene exit observers before calling it on systems + // TODO: Consider hooks for components instead of direct node component references + const SkaComponentType entityComponentSignature = ska_ecs_component_manager_get_component_signature(entity); + for (usize i = 0; i < entitySystemData.on_entity_end_systems_count; i++) { + SkaECSSystem* ecsSystem = entitySystemData.on_entity_end_systems[i]; + if (SKA_FLAG_CONTAINS(entityComponentSignature, ecsSystem->component_signature)) { + ecsSystem->on_entity_end_func(ecsSystem, entity); + } + } +// NodeComponent* nodeComponent = (NodeComponent*)ska_ecs_component_manager_get_component_unchecked(entity, CreComponentDataIndex_NODE); +// if (nodeComponent != NULL) { +// // Note: Node events should not be created during this time +// ska_event_notify_observers(&nodeComponent->onSceneTreeExit, &(SkaSubjectNotifyPayload) { +// .data = &entity +// }); +// } +} + +void ska_ecs_system_event_entity_entered_scene(SkaEntity entity) { + // Notify scene enter observers before calling it on systems +// NodeComponent* nodeComponent = (NodeComponent*) ska_ecs_component_manager_get_component_unchecked(entity, CreComponentDataIndex_NODE); +// if (nodeComponent != NULL) { +// ska_event_notify_observers(&nodeComponent->onSceneTreeEnter, &(SkaSubjectNotifyPayload) { +// .data = &entity +// }); +// } + const SkaComponentType entityComponentSignature = ska_ecs_component_manager_get_component_signature(entity); + for (usize i = 0; i < entitySystemData.on_entity_entered_scene_systems_count; i++) { + SkaECSSystem* ecsSystem = entitySystemData.on_entity_entered_scene_systems[i]; + if (SKA_FLAG_CONTAINS(entityComponentSignature, ecsSystem->component_signature)) { + ecsSystem->on_entity_entered_scene_func(ecsSystem, entity); + } + } +} + +void ska_ecs_system_event_render_systems() { + for (usize i = 0; i < entitySystemData.render_systems_count; i++) { + SkaECSSystem* ecsSystem = entitySystemData.render_systems[i]; + ecsSystem->render_func(ecsSystem); + } +} + +void ska_ecs_system_event_pre_update_all_systems() { + for (usize i = 0; i < entitySystemData.pre_update_all_systems_count; i++) { + SkaECSSystem* ecsSystem = entitySystemData.pre_update_all_systems[i]; + ecsSystem->pre_update_all_func(ecsSystem); + } +} + +void ska_ecs_system_event_post_update_all_systems() { + for (usize i = 0; i < entitySystemData.post_update_all_systems_count; i++) { + SkaECSSystem* ecsSystem = entitySystemData.post_update_all_systems[i]; + ecsSystem->post_update_all_func(ecsSystem); + } +} + +void ska_ecs_system_event_update_systems(f32 deltaTime) { + for (usize i = 0; i < entitySystemData.update_systems_count; i++) { + SkaECSSystem* ecsSystem = entitySystemData.update_systems[i]; + ecsSystem->update_func(ecsSystem, deltaTime); + } +} + +void ska_ecs_system_event_fixed_update_systems(f32 deltaTime) { + for (usize i = 0; i < entitySystemData.fixed_update_systems_count; i++) { + SkaECSSystem* ecsSystem = entitySystemData.fixed_update_systems[i]; + ecsSystem->fixed_update_func(ecsSystem, deltaTime); + } +} + +void ska_ecs_system_event_network_callback(const char* message) { + for (usize i = 0; i < entitySystemData.network_callback_systems_count; i++) { + SkaECSSystem* ecsSystem = entitySystemData.network_callback_systems[i]; + ecsSystem->network_callback_func(ecsSystem, message); + } +} + +// --- Internal Functions --- // +bool ska_ecs_system_has_entity(SkaEntity entity, SkaECSSystem* system) { + for (usize i = 0; i < system->entity_count; i++) { + if (entity == system->entities[i]) { + return true; + } + } + return false; +} + +void ska_ecs_system_insert_entity_into_system(SkaEntity entity, SkaECSSystem* system) { + if (!ska_ecs_system_has_entity(entity, system)) { + system->entities[system->entity_count++] = entity; + if (system->on_entity_registered_func != NULL) { + system->on_entity_registered_func(system, entity); + } + } else { + ska_logger_internal_queue_message("Entity '%d' already in system '%s'", entity, system->name); + } +} + +void ska_ecs_system_remove_entity_from_system(SkaEntity entity, SkaECSSystem* system) { + for (usize i = 0; i < system->entity_count; i++) { + if (entity == system->entities[i]) { + // Entity found + if (i + 1 < SKA_MAX_ENTITIES) { + system->entities[i] = SKA_NULL_ENTITY; + } + if (system->on_entity_unregistered_func != NULL) { + system->on_entity_unregistered_func(system, entity); + } + + // Condense array + for (usize newIndex = i; i < system->entity_count; i++) { + if (system->entities[i] == SKA_NULL_ENTITY) { + // Early exit if 2 consecutive nulls + if (system->entities[i + 1] == SKA_NULL_ENTITY) { + break; + } + system->entities[i] = system->entities[i + 1]; + system->entities[i + 1] = SKA_NULL_ENTITY; + } + } + + system->entity_count--; + break; + } + } +} + +void ska_ecs_system_remove_entity_from_all_systems(SkaEntity entity) { + for (usize i = 0; i < entitySystemData.entity_systems_count; i++) { + ska_ecs_system_remove_entity_from_system(entity, entitySystemData.entity_systems[i]); + } +} diff --git a/seika1/ecs/ec_system.h b/seika1/ecs/ec_system.h new file mode 100644 index 0000000..98ba3cb --- /dev/null +++ b/seika1/ecs/ec_system.h @@ -0,0 +1,110 @@ +#pragma once + +#include "component.h" + +#define SKA_ECS_SYSTEM_CREATE(NAME, ...) \ +ska_ecs_system_create_with_signature_string(NAME, #__VA_ARGS__) + +#define SKA_ECS_SYSTEM_CREATE_FROM_TEMPLATE(TEMPLATE, ...) \ +ska_ecs_system_create_from_template_with_signature_string(TEMPLATE, #__VA_ARGS__) + +// Creates and register system from template +#define SKA_ECS_SYSTEM_REGISTER_FROM_TEMPLATE(TEMPLATE, ...) \ +ska_ecs_system_register(ska_ecs_system_create_from_template_with_signature_string(TEMPLATE, #__VA_ARGS__)) + +struct SkaECSSystem; + +typedef void (*OnECSystemRegister) (struct SkaECSSystem*); +typedef void (*OnECSystemDestroy) (struct SkaECSSystem*); +typedef void (*OnEntityRegisteredFunc) (struct SkaECSSystem*, SkaEntity); // init +typedef void (*OnEntityStartFunc) (struct SkaECSSystem*, SkaEntity); // Useful for after initialization functionality (such as entering a scene) +typedef void (*OnEntityEndFunc) (struct SkaECSSystem*, SkaEntity); // Useful for before deletion functionality (such as leaving a scene) +typedef void (*OnEntityUnRegisteredFunc) (struct SkaECSSystem*, SkaEntity); // delete +typedef void (*OnEntityEnteredSceneFunc) (struct SkaECSSystem*, SkaEntity); // When entity enters a scene (after _start() is called) +typedef void (*RenderFunc) (struct SkaECSSystem*); +typedef void (*PreProcessAllFunc) (struct SkaECSSystem*); +typedef void (*PostProcessAllFunc) (struct SkaECSSystem*); +typedef void (*UpdateFunc) (struct SkaECSSystem*, float); +typedef void (*FixedUpdateFunc) (struct SkaECSSystem*, float); +typedef void (*NetworkCallbackFunc) (struct SkaECSSystem*, const char*); + +typedef struct SkaECSSystem { + char* name; + // Event callbacks + OnECSystemRegister on_ec_system_register; // happens on register + OnECSystemDestroy on_ec_system_destroy; + OnEntityRegisteredFunc on_entity_registered_func; + OnEntityStartFunc on_entity_start_func; + OnEntityEndFunc on_entity_end_func; + OnEntityUnRegisteredFunc on_entity_unregistered_func; + OnEntityEnteredSceneFunc on_entity_entered_scene_func; + RenderFunc render_func; + PreProcessAllFunc pre_update_all_func; + PostProcessAllFunc post_update_all_func; + UpdateFunc update_func; + FixedUpdateFunc fixed_update_func; + NetworkCallbackFunc network_callback_func; + SkaComponentType component_signature; + usize entity_count; + // Keeps track of entities that match a component signature + SkaEntity entities[SKA_MAX_ENTITIES]; +} SkaECSSystem; + +typedef struct SkaECSSystemTemplate { + const char* name; + OnECSystemRegister on_ec_system_register; + OnECSystemDestroy on_ec_system_destroy; + OnEntityRegisteredFunc on_entity_registered_func; + OnEntityStartFunc on_entity_start_func; + OnEntityEndFunc on_entity_end_func; + OnEntityUnRegisteredFunc on_entity_unregistered_func; + OnEntityEnteredSceneFunc on_entity_entered_scene_func; + RenderFunc render_func; + PreProcessAllFunc pre_update_all_func; + PostProcessAllFunc post_update_all_func; + UpdateFunc update_func; + FixedUpdateFunc fixed_update_func; + NetworkCallbackFunc network_callback_func; +} SkaECSSystemTemplate; + +// example system template +#define SKA_ECS_SYSTEM_TEMPLATE_STRUCT SKA_STRUCT_LITERAL(SkaECSSystemTemplate){ \ + .name = "example template system", \ + .on_ec_system_register = NULL, \ + .on_ec_system_destroy = NULL, \ + .on_entity_registered_func = NULL, \ + .on_entity_start_func = NULL, \ + .on_entity_end_func = NULL, \ + .on_entity_unregistered_func = NULL, \ + .on_entity_entered_scene_func = NULL, \ + .render_func = NULL, \ + .pre_update_all_func = NULL, \ + .post_update_all_func = NULL, \ + .update_func = NULL, \ + .fixed_update_func = NULL, \ + .network_callback_func = NULL \ +} + +void ska_ecs_system_initialize(); +void ska_ecs_system_finalize(); +SkaECSSystem* ska_ecs_system_create(const char* systemName); +SkaECSSystem* ska_ecs_system_create_from_template(SkaECSSystemTemplate* systemTemplate); +SkaECSSystem* ska_ecs_system_create_with_signature_string(const char* systemName, const char* signatures); +SkaECSSystem* ska_ecs_system_create_from_template_with_signature_string(SkaECSSystemTemplate* systemTemplate, const char* signatures); +SkaECSSystemTemplate ska_ecs_system_create_default_template(const char* systemName); +void ska_ecs_system_destroy(SkaECSSystem* entitySystem); +void ska_ecs_system_register(SkaECSSystem* system); +void ska_ecs_system_update_entity_signature_with_systems(SkaEntity entity); +void ska_ecs_system_remove_entity_from_all_systems(SkaEntity entity); +bool ska_ecs_system_has_entity(SkaEntity entity, SkaECSSystem* system); + +// Event functions +void ska_ecs_system_event_entity_start(SkaEntity entity); +void ska_ecs_system_event_entity_end(SkaEntity entity); +void ska_ecs_system_event_entity_entered_scene(SkaEntity entity); +void ska_ecs_system_event_render_systems(); +void ska_ecs_system_event_pre_update_all_systems(); +void ska_ecs_system_event_post_update_all_systems(); +void ska_ecs_system_event_update_systems(f32 deltaTime); +void ska_ecs_system_event_fixed_update_systems(f32 deltaTime); +void ska_ecs_system_event_network_callback(const char* message); diff --git a/seika1/ecs/ecs.c b/seika1/ecs/ecs.c new file mode 100644 index 0000000..e269fe2 --- /dev/null +++ b/seika1/ecs/ecs.c @@ -0,0 +1,13 @@ +#include "ecs.h" + +void ska_ecs_initialize() { + ska_ecs_entity_initialize(); + ska_ecs_system_initialize(); + ska_ecs_component_manager_initialize(); +} + +void ska_ecs_finalize() { + ska_ecs_entity_finalize(); + ska_ecs_component_manager_finalize(); + ska_ecs_system_finalize(); +} diff --git a/seika1/ecs/ecs.h b/seika1/ecs/ecs.h new file mode 100644 index 0000000..7b7e0a0 --- /dev/null +++ b/seika1/ecs/ecs.h @@ -0,0 +1,6 @@ +#pragma once + +#include "ec_system.h" + +void ska_ecs_initialize(); +void ska_ecs_finalize(); diff --git a/seika1/ecs/entity.c b/seika1/ecs/entity.c new file mode 100644 index 0000000..bfb6b04 --- /dev/null +++ b/seika1/ecs/entity.c @@ -0,0 +1,43 @@ +#include "entity.h" +#include "seika/data_structures/queue.h" +#include "seika/assert.h" + +static SkaQueue* entityIdQueue = NULL; +static SkaEntity entityIdCounter = 0; +static usize activeEntityCount = 0; + +void ska_ecs_entity_initialize() { + SKA_ASSERT(entityIdQueue == NULL); + entityIdQueue = ska_queue_create(SKA_MAX_ENTITIES, SKA_NULL_ENTITY); + while (entityIdCounter < 100) { + ska_queue_enqueue(entityIdQueue, entityIdCounter++); + } +} + +void ska_ecs_entity_finalize() { + SKA_ASSERT(entityIdQueue); + ska_queue_destroy(entityIdQueue); + entityIdQueue = NULL; + entityIdCounter = 0; + activeEntityCount = 0; +} + +SkaEntity ska_ecs_entity_create() { + SKA_ASSERT(entityIdQueue); + if (ska_queue_is_empty(entityIdQueue)) { + SKA_ASSERT_FMT(entityIdCounter < SKA_MAX_ENTITIES, "Reached maxed entities ids to create, considering increasing SKA_MAX_ENTITIES!"); + ska_queue_enqueue(entityIdQueue, entityIdCounter++); + } + activeEntityCount++; + return ska_queue_dequeue(entityIdQueue); +} + +void ska_ecs_entity_return(SkaEntity entity) { + SKA_ASSERT(entityIdQueue); + ska_queue_enqueue(entityIdQueue,entity); + activeEntityCount--; +} + +usize ska_ecs_entity_get_active_count() { + return activeEntityCount; +} diff --git a/seika1/ecs/entity.h b/seika1/ecs/entity.h new file mode 100644 index 0000000..ec958b0 --- /dev/null +++ b/seika1/ecs/entity.h @@ -0,0 +1,24 @@ +#pragma once + +#include + +#include "seika/defines.h" + +// Entity is defined as a unsigned 32-bit integer + +// Gives a chance for users to set own max entities +#ifndef SKA_MAX_ENTITIES +#define SKA_MAX_ENTITIES 200000 // starting with 200,000 for now +#endif + +#define SKA_NULL_ENTITY UINT32_MAX + +typedef uint32 SkaEntity; + +void ska_ecs_entity_initialize(); +void ska_ecs_entity_finalize(); +// Pops entity from the queue +SkaEntity ska_ecs_entity_create(); +// Push entity to the queue +void ska_ecs_entity_return(SkaEntity entity); +usize ska_ecs_entity_get_active_count(); diff --git a/test/test1.c b/test/test1.c index 325cdf3..f20166b 100644 --- a/test/test1.c +++ b/test/test1.c @@ -3,6 +3,7 @@ #include "seika1/memory.h" #include "seika1/data_structures/array_list.h" +#include "seika1/data_structures/queue.h" #define RESOURCES_PATH "test/resources" #define RESOURCES_PACK_PATH "test/resources/test.pck" @@ -12,6 +13,7 @@ void tearDown(void) {} void seika_mem_test(void); void seika_array_list_test(void); +void seika_queue_test(void); int32 main(int32 argv, char** args) { UNITY_BEGIN(); @@ -58,3 +60,5 @@ void seika_array_list_test(void) { TEST_ASSERT_TRUE(ska_array_list_is_empty(arrayList)); ska_array_list_destroy(arrayList); } + +void seika_queue_test(void) {} From 1de543e66ba5376d46065d85460c398f387395c5 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 17 Oct 2024 14:03:02 -0400 Subject: [PATCH 11/55] Updates. --- seika/data_structures/queue.h | 20 ++++---- seika1/data_structures/id_queue.c | 77 +++++++++++++++++++++++++++++++ seika1/data_structures/id_queue.h | 21 +++++++++ seika1/data_structures/queue.c | 60 ------------------------ seika1/data_structures/queue.h | 27 ----------- seika1/ecs/entity.c | 2 +- test/test1.c | 32 +++++++++++-- 7 files changed, 138 insertions(+), 101 deletions(-) create mode 100644 seika1/data_structures/id_queue.c create mode 100644 seika1/data_structures/id_queue.h delete mode 100644 seika1/data_structures/queue.c delete mode 100644 seika1/data_structures/queue.h diff --git a/seika/data_structures/queue.h b/seika/data_structures/queue.h index 1377368..d388600 100644 --- a/seika/data_structures/queue.h +++ b/seika/data_structures/queue.h @@ -8,17 +8,17 @@ // TODO: If other types are needed, create a macro to simplify queues by type // Unsigned int queue -typedef struct SkaQueue { +typedef struct SkaIdQueue { uint32 front, rear, size, invalidValue; usize capacity; uint32* array; -} SkaQueue; +} SkaIdQueue; -SkaQueue* ska_queue_create(usize capacity, uint32 invalidValue); -void ska_queue_destroy(SkaQueue* queue); -bool ska_queue_is_full(SkaQueue* queue); -bool ska_queue_is_empty(SkaQueue* queue); -void ska_queue_enqueue(SkaQueue* queue, uint32 item); -uint32 ska_queue_dequeue(SkaQueue* queue); -uint32 ska_queue_front(SkaQueue* queue); -uint32 ska_queue_rear(SkaQueue* queue); +SkaIdQueue* ska_queue_create(usize capacity, uint32 invalidValue); +void ska_queue_destroy(SkaIdQueue* queue); +bool ska_queue_is_full(SkaIdQueue* queue); +bool ska_queue_is_empty(SkaIdQueue* queue); +void ska_queue_enqueue(SkaIdQueue* queue, uint32 item); +uint32 ska_queue_dequeue(SkaIdQueue* queue); +uint32 ska_queue_front(SkaIdQueue* queue); +uint32 ska_queue_rear(SkaIdQueue* queue); diff --git a/seika1/data_structures/id_queue.c b/seika1/data_structures/id_queue.c new file mode 100644 index 0000000..6845c3b --- /dev/null +++ b/seika1/data_structures/id_queue.c @@ -0,0 +1,77 @@ +#include "id_queue.h" + +#include "seika1/assert.h" +#include "seika1/memory.h" + +SkaIdQueue* ska_id_queue_create(usize initialCapacity) { + SkaIdQueue* queue = SKA_ALLOC(SkaIdQueue); + queue->capacity = initialCapacity; + queue->size = initialCapacity; + queue->front = 0; + queue->rear = (SKA_QUEUE_T)initialCapacity - 1; + queue->array = (SKA_QUEUE_T*)SKA_ALLOC_BYTES(queue->capacity * sizeof(SKA_QUEUE_T)); + for (SKA_QUEUE_T i = 0; i < initialCapacity; i++) { + queue->array[i] = i; + } + return queue; +} + +void ska_id_queue_destroy(SkaIdQueue* queue) { + SKA_FREE(queue->array); + SKA_FREE(queue); +} + +bool ska_id_queue_is_full(SkaIdQueue* queue) { + return queue->size == queue->capacity; +} + +bool ska_id_queue_is_empty(SkaIdQueue* queue) { + return queue->size == 0; +} + +bool ska_id_queue_enqueue(SkaIdQueue* queue, SKA_QUEUE_T item) { + if (ska_id_queue_is_full(queue)) { + return false; + } + queue->rear = (queue->rear + 1) % queue->capacity; + queue->array[queue->rear] = item; + queue->size++; + return true; +} + +bool ska_id_queue_dequeue(SkaIdQueue* queue, SKA_QUEUE_T* outId) { + // If id queue is empty recreate data array + if (ska_id_queue_is_empty(queue)) { + SKA_FREE(queue->array); + const usize prevCapacity = queue->capacity; + queue->capacity *= 2; + queue->array = (SKA_QUEUE_T*)SKA_ALLOC_BYTES_ZEROED(queue->capacity * sizeof(SKA_QUEUE_T)); + for (SKA_QUEUE_T i = prevCapacity; i < queue->capacity; i++) { + queue->array[i] = i; + } + + queue->front = prevCapacity; + queue->rear = queue->capacity - 1; + queue->size = prevCapacity; + } + *outId = queue->array[queue->front]; + queue->front = (queue->front + 1) % queue->capacity; + queue->size--; + return true; +} + +bool ska_id_queue_front(SkaIdQueue* queue, SKA_QUEUE_T* outId) { + if (ska_id_queue_is_empty(queue) || outId == NULL) { + return false; + } + *outId = queue->array[queue->front]; + return true; +} + +bool ska_id_queue_rear(SkaIdQueue* queue, SKA_QUEUE_T* outId) { + if (ska_id_queue_is_empty(queue) || outId == NULL) { + return false; + } + *outId = queue->array[queue->rear]; + return true; +} diff --git a/seika1/data_structures/id_queue.h b/seika1/data_structures/id_queue.h new file mode 100644 index 0000000..379428f --- /dev/null +++ b/seika1/data_structures/id_queue.h @@ -0,0 +1,21 @@ +#pragma once + +#define SKA_QUEUE_T uint32 + +#include "seika1/defines.h" + +// Unsigned int queue +typedef struct SkaIdQueue { + usize front, rear, size; + usize capacity; + SKA_QUEUE_T* array; +} SkaIdQueue; + +SkaIdQueue* ska_id_queue_create(usize initialCapacity); +void ska_id_queue_destroy(SkaIdQueue* queue); +bool ska_id_queue_is_full(SkaIdQueue* queue); +bool ska_id_queue_is_empty(SkaIdQueue* queue); +bool ska_id_queue_enqueue(SkaIdQueue* queue, SKA_QUEUE_T item); +bool ska_id_queue_dequeue(SkaIdQueue* queue, SKA_QUEUE_T* outId); +bool ska_id_queue_front(SkaIdQueue* queue, SKA_QUEUE_T* outId); +bool ska_id_queue_rear(SkaIdQueue* queue, SKA_QUEUE_T* outId); diff --git a/seika1/data_structures/queue.c b/seika1/data_structures/queue.c deleted file mode 100644 index e92060d..0000000 --- a/seika1/data_structures/queue.c +++ /dev/null @@ -1,60 +0,0 @@ -#include "queue.h" - -#include "seika1/memory.h" - -SkaQueue* ska_queue_create(usize capacity, uint32 invalidValue) { - SkaQueue* queue = SKA_ALLOC(SkaQueue); - queue->capacity = capacity; - queue->invalidValue = invalidValue; - queue->size = 0; - queue->front = 0; - queue->rear = (uint32)capacity - 1; - queue->array = (uint32*)SKA_ALLOC_BYTES(queue->capacity * sizeof(uint32)); - return queue; -} - -void ska_queue_destroy(SkaQueue* queue) { - SKA_FREE(queue->array); - SKA_FREE(queue); -} - -bool ska_queue_is_full(SkaQueue* queue) { - return queue->size == queue->capacity; -} - -bool ska_queue_is_empty(SkaQueue* queue) { - return queue->size == 0; -} - -void ska_queue_enqueue(SkaQueue* queue, uint32 item) { - if (ska_queue_is_full(queue)) { - return; - } - queue->rear = (queue->rear + 1) % queue->capacity; - queue->array[queue->rear] = item; - queue->size++; -} - -uint32 ska_queue_dequeue(SkaQueue* queue) { - if (ska_queue_is_empty(queue)) { - return queue->invalidValue; - } - uint32 value = queue->array[queue->front]; - queue->front = (queue->front + 1) % queue->capacity; - queue->size--; - return value; -} - -uint32 ska_queue_front(SkaQueue* queue) { - if (ska_queue_is_empty(queue)) { - return queue->invalidValue; - } - return queue->array[queue->front]; -} - -uint32 ska_queue_rear(SkaQueue* queue) { - if (ska_queue_is_empty(queue)) { - return queue->invalidValue; - } - return queue->array[queue->rear]; -} diff --git a/seika1/data_structures/queue.h b/seika1/data_structures/queue.h deleted file mode 100644 index 85ec390..0000000 --- a/seika1/data_structures/queue.h +++ /dev/null @@ -1,27 +0,0 @@ -#pragma once - -// #define SKA_QUEUE_TEMPLATE uint32 -// #include "queue_template.h" -// #define SKA_QUEUE_TEMPLATE int32 -// #include "queue_template.h" -// #undef SKA_QUEUE_TEMPLATE - -#include "seika1/defines.h" - -// TODO: If other types are needed, create a macro to simplify queues by type - -// Unsigned int queue -typedef struct SkaQueue { - uint32 front, rear, size, invalidValue; - usize capacity; - uint32* array; -} SkaQueue; - -SkaQueue* ska_queue_create(usize capacity, uint32 invalidValue); -void ska_queue_destroy(SkaQueue* queue); -bool ska_queue_is_full(SkaQueue* queue); -bool ska_queue_is_empty(SkaQueue* queue); -void ska_queue_enqueue(SkaQueue* queue, uint32 item); -uint32 ska_queue_dequeue(SkaQueue* queue); -uint32 ska_queue_front(SkaQueue* queue); -uint32 ska_queue_rear(SkaQueue* queue); diff --git a/seika1/ecs/entity.c b/seika1/ecs/entity.c index bfb6b04..013b128 100644 --- a/seika1/ecs/entity.c +++ b/seika1/ecs/entity.c @@ -2,7 +2,7 @@ #include "seika/data_structures/queue.h" #include "seika/assert.h" -static SkaQueue* entityIdQueue = NULL; +static SkaIdQueue* entityIdQueue = NULL; static SkaEntity entityIdCounter = 0; static usize activeEntityCount = 0; diff --git a/test/test1.c b/test/test1.c index f20166b..c6a46c7 100644 --- a/test/test1.c +++ b/test/test1.c @@ -3,7 +3,7 @@ #include "seika1/memory.h" #include "seika1/data_structures/array_list.h" -#include "seika1/data_structures/queue.h" +#include "seika1/data_structures/id_queue.h" #define RESOURCES_PATH "test/resources" #define RESOURCES_PACK_PATH "test/resources/test.pck" @@ -13,12 +13,13 @@ void tearDown(void) {} void seika_mem_test(void); void seika_array_list_test(void); -void seika_queue_test(void); +void seika_id_queue_test(void); int32 main(int32 argv, char** args) { UNITY_BEGIN(); RUN_TEST(seika_mem_test); RUN_TEST(seika_array_list_test); + RUN_TEST(seika_id_queue_test); return UNITY_END(); } @@ -61,4 +62,29 @@ void seika_array_list_test(void) { ska_array_list_destroy(arrayList); } -void seika_queue_test(void) {} +void seika_id_queue_test(void) { + SkaIdQueue* idQueue = ska_id_queue_create(10); + + uint32 value; + for (uint32 i = 0; i < 10; i++) { + ska_id_queue_dequeue(idQueue, &value); + TEST_ASSERT_EQUAL_UINT32(i, value); + } + + TEST_ASSERT_TRUE(ska_id_queue_is_empty(idQueue)); + + // + ska_id_queue_enqueue(idQueue, 4); + ska_id_queue_enqueue(idQueue, 6); + ska_id_queue_enqueue(idQueue, 5); + ska_id_queue_dequeue(idQueue, &value); + TEST_ASSERT_EQUAL_UINT32(4, value); + ska_id_queue_dequeue(idQueue, &value); + TEST_ASSERT_EQUAL_UINT32(6, value); + ska_id_queue_dequeue(idQueue, &value); + TEST_ASSERT_EQUAL_UINT32(5, value); + + ska_id_queue_dequeue(idQueue, &value); + TEST_ASSERT_EQUAL_UINT32(10, value); + TEST_ASSERT_EQUAL_size_t(20, idQueue->capacity); +} From 738358c2994b6bd538f16e1454876e8688629073 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 17 Oct 2024 15:40:55 -0400 Subject: [PATCH 12/55] More tests. --- seika1/data_structures/array_list.c | 13 ++++- seika1/data_structures/array_list.h | 4 +- seika1/ecs/component.c | 81 +++++++++++------------------ seika1/ecs/ec_system.c | 69 +++++------------------- seika1/ecs/ec_system.h | 7 +-- seika1/ecs/ecs.h | 1 + seika1/ecs/entity.c | 25 ++++----- seika1/ecs/entity.h | 13 +---- 8 files changed, 73 insertions(+), 140 deletions(-) diff --git a/seika1/data_structures/array_list.c b/seika1/data_structures/array_list.c index 641569b..318c701 100644 --- a/seika1/data_structures/array_list.c +++ b/seika1/data_structures/array_list.c @@ -13,7 +13,7 @@ SkaArrayList* ska_array_list_create_default_capacity(usize valueSize) { SkaArrayList* ska_array_list_create(usize valueSize, usize initialCapacity) { SkaArrayList* newList = SKA_ALLOC(SkaArrayList); - newList->data = SKA_ALLOC_BYTES(initialCapacity * valueSize); + newList->data = SKA_ALLOC_BYTES_ZEROED(initialCapacity * valueSize); newList->valueSize = valueSize; newList->capacity = initialCapacity; newList->initialCapacity = initialCapacity; @@ -69,7 +69,16 @@ bool ska_array_list_remove_by_index(SkaArrayList* list, usize index) { return false; } -bool ska_array_list_is_empty(SkaArrayList *list) { +bool ska_array_list_has(const SkaArrayList* list, const void* value) { + for (usize i = 0; i < list->size; i++) { + if (memcmp((char*)list->data + i * list->valueSize, value, list->valueSize) == 0) { + return true; + } + } + return false; +} + +bool ska_array_list_is_empty(const SkaArrayList *list) { return list->size == 0; } diff --git a/seika1/data_structures/array_list.h b/seika1/data_structures/array_list.h index ea6542c..1e6bc00 100644 --- a/seika1/data_structures/array_list.h +++ b/seika1/data_structures/array_list.h @@ -26,7 +26,9 @@ void* ska_array_list_get(SkaArrayList* list, usize index); // Removes the first item from the list who is equal to the passed in value bool ska_array_list_remove(SkaArrayList* list, const void* value); bool ska_array_list_remove_by_index(SkaArrayList* list, usize index); +// Returns true if the item exists within the list +bool ska_array_list_has(const SkaArrayList* list, const void* value); // Returns true if the array list size == 0 -bool ska_array_list_is_empty(SkaArrayList *list); +bool ska_array_list_is_empty(const SkaArrayList *list); // Will remove all items from the array list void ska_array_list_clear(SkaArrayList *list); diff --git a/seika1/ecs/component.c b/seika1/ecs/component.c index 0aee34a..0a9bec3 100644 --- a/seika1/ecs/component.c +++ b/seika1/ecs/component.c @@ -1,11 +1,10 @@ #include "component.h" -#include - -#include "seika/string.h" -#include "seika/memory.h" -#include "seika/assert.h" -#include "seika/data_structures/hash_map_string.h" +#include "seika1/string.h" +#include "seika1/memory.h" +#include "seika1/assert.h" +#include "seika1/data_structures/hash_map_string.h" +#include "seika1/data_structures/array_list.h" //--- Component ---// static SkaComponentIndex globalComponentIndex = 0; @@ -50,22 +49,9 @@ SkaComponentType ska_ecs_component_get_type_flag(const char* name, usize compone //--- Component Array ---// typedef struct ComponentArray { void* components[SKA_ECS_MAX_COMPONENTS]; + SkaComponentType signature; } ComponentArray; -static ComponentArray* component_array_create() { - ComponentArray* componentArray = SKA_MEM_ALLOCATE(ComponentArray); - for (unsigned int i = 0; i < SKA_ECS_MAX_COMPONENTS; i++) { - componentArray->components[i] = NULL; - } - return componentArray; -} - -static void component_array_initialize(ComponentArray* componentArray) { - for (unsigned int i = 0; i < SKA_ECS_MAX_COMPONENTS; i++) { - componentArray->components[i] = NULL; - } -} - static bool component_array_has_component(ComponentArray* componentArray, SkaComponentIndex index) { return componentArray->components[index] == NULL ? false : true; } @@ -79,7 +65,7 @@ static void component_array_set_component(ComponentArray* componentArray, SkaCom } static void component_array_remove_component(ComponentArray* componentArray, SkaComponentIndex index) { - SKA_MEM_FREE(componentArray->components[index]); + SKA_FREE(componentArray->components[index]); componentArray->components[index] = NULL; } @@ -87,15 +73,15 @@ static void component_array_remove_all_components(ComponentArray* componentArray for (usize i = 0; i < SKA_ECS_MAX_COMPONENTS; i++) { component_array_remove_component(componentArray, (SkaComponentIndex)i); } + componentArray->signature = SKA_ECS_COMPONENT_TYPE_NONE; } //--- Component Manager ---// typedef struct ComponentManager { - ComponentArray entityComponentArrays[SKA_MAX_ENTITIES]; - SkaComponentType entityComponentSignatures[SKA_MAX_ENTITIES]; + SkaArrayList* componentArrays; } ComponentManager; -static ComponentManager* componentManager = NULL; +static ComponentManager componentManager = { .componentArrays = NULL }; static SkaComponentType component_manager_translate_index_to_type(SkaComponentIndex index); @@ -103,8 +89,8 @@ void ska_ecs_component_manager_initialize() { SKA_ASSERT(componentNameToTypeMap == NULL); componentNameToTypeMap = ska_string_hash_map_create_default_capacity(); - SKA_ASSERT_FMT(componentManager == NULL, "Component Manager is not NULL when trying to initialize"); - componentManager = SKA_MEM_ALLOCATE(ComponentManager); + SKA_ASSERT_FMT(componentManager.componentArrays == NULL, "Component Manager's component arrays are not NULL when trying to initialize"); + componentManager.componentArrays = ska_array_list_create(sizeof(ComponentArray), 1000); } // Assumes component data was already deleted previously @@ -114,58 +100,49 @@ void ska_ecs_component_manager_finalize() { SkaStringHashMapNode* node = iter.pair; SkaComponentTypeInfo* typeInfo = (SkaComponentTypeInfo*)node->value; if (typeInfo) { - SKA_MEM_FREE(typeInfo->name); + SKA_FREE(typeInfo->name); } } ska_string_hash_map_destroy(componentNameToTypeMap); componentNameToTypeMap = NULL; globalComponentIndex = 0; - SKA_ASSERT_FMT(componentManager != NULL, "Component Manager is NULL when trying to finalize..."); - SKA_MEM_FREE(componentManager); - componentManager = NULL; + SKA_ASSERT_FMT(componentManager.componentArrays != NULL, "Component Manager is NULL when trying to finalize..."); + ska_array_list_destroy(componentManager.componentArrays); + componentManager.componentArrays = NULL; } void* ska_ecs_component_manager_get_component(SkaEntity entity, SkaComponentIndex index) { - void* component = component_array_get_component(&componentManager->entityComponentArrays[entity], index); + void* component = ska_ecs_component_manager_get_component_unchecked(entity, index); SKA_ASSERT_FMT(component != NULL, "Entity '%d' doesn't have '%s' component!", entity, ska_ecs_component_get_component_data_index_string(index)); return component; } void* ska_ecs_component_manager_get_component_unchecked(SkaEntity entity, SkaComponentIndex index) { - return component_array_get_component(&componentManager->entityComponentArrays[entity], index); + ComponentArray* componentArray = ska_array_list_get(componentManager.componentArrays, (usize)entity); + return component_array_get_component(componentArray, index); } void ska_ecs_component_manager_set_component(SkaEntity entity, SkaComponentIndex index, void* component) { - component_array_set_component(&componentManager->entityComponentArrays[entity], index, component); - // Update signature - SkaComponentType componentSignature = ska_ecs_component_manager_get_component_signature(entity); - componentSignature |= component_manager_translate_index_to_type(index); - ska_ecs_component_manager_set_component_signature(entity, componentSignature); + ComponentArray* componentArray = ska_array_list_get(componentManager.componentArrays, (usize)entity); + component_array_set_component(componentArray, index, component); + componentArray->signature |= component_manager_translate_index_to_type(index); } void ska_ecs_component_manager_remove_component(SkaEntity entity, SkaComponentIndex index) { - SkaComponentType componentSignature = ska_ecs_component_manager_get_component_signature(entity); - componentSignature &= component_manager_translate_index_to_type(index); - ska_ecs_component_manager_set_component_signature(entity, componentSignature); - component_array_remove_component(&componentManager->entityComponentArrays[entity], index); + ComponentArray* componentArray = ska_array_list_get(componentManager.componentArrays, (usize)entity); + componentArray->signature &= component_manager_translate_index_to_type(index); + component_array_remove_component(componentArray, index); } void ska_ecs_component_manager_remove_all_components(SkaEntity entity) { - component_array_remove_all_components(&componentManager->entityComponentArrays[entity]); - ska_ecs_component_manager_set_component_signature(entity, SKA_ECS_COMPONENT_TYPE_NONE); + ComponentArray* componentArray = ska_array_list_get(componentManager.componentArrays, (usize)entity); + component_array_remove_all_components(componentArray); } bool ska_ecs_component_manager_has_component(SkaEntity entity, SkaComponentIndex index) { - return component_array_has_component(&componentManager->entityComponentArrays[entity], index); -} - -void ska_ecs_component_manager_set_component_signature(SkaEntity entity, SkaComponentType componentTypeSignature) { - componentManager->entityComponentSignatures[entity] = componentTypeSignature; -} - -SkaComponentType ska_ecs_component_manager_get_component_signature(SkaEntity entity) { - return componentManager->entityComponentSignatures[entity]; + ComponentArray* componentArray = ska_array_list_get(componentManager.componentArrays, (usize)entity); + return component_array_has_component(componentArray, index); } SkaComponentType component_manager_translate_index_to_type(SkaComponentIndex index) { diff --git a/seika1/ecs/ec_system.c b/seika1/ecs/ec_system.c index f5afd9b..2b1b0eb 100644 --- a/seika1/ecs/ec_system.c +++ b/seika1/ecs/ec_system.c @@ -54,12 +54,12 @@ void ska_ecs_system_finalize() { SkaECSSystem* ska_ecs_system_create(const char* systemName) { SkaECSSystem* newSystem = SKA_MEM_ALLOCATE(SkaECSSystem); newSystem->name = ska_strdup(systemName); + newSystem->entities = ska_array_list_create_default_capacity(sizeof(SkaEntity)); return newSystem; } SkaECSSystem* ska_ecs_system_create_from_template(SkaECSSystemTemplate* systemTemplate) { - SkaECSSystem* newSystem = SKA_MEM_ALLOCATE(SkaECSSystem); - newSystem->name = ska_strdup(systemTemplate->name); + SkaECSSystem* newSystem = ska_ecs_system_create(systemTemplate->name); newSystem->on_ec_system_register = systemTemplate->on_ec_system_register; newSystem->on_ec_system_destroy = systemTemplate->on_ec_system_destroy; newSystem->on_entity_registered_func = systemTemplate->on_entity_registered_func; @@ -206,23 +206,9 @@ void ska_ecs_system_event_entity_end(SkaEntity entity) { ecsSystem->on_entity_end_func(ecsSystem, entity); } } -// NodeComponent* nodeComponent = (NodeComponent*)ska_ecs_component_manager_get_component_unchecked(entity, CreComponentDataIndex_NODE); -// if (nodeComponent != NULL) { -// // Note: Node events should not be created during this time -// ska_event_notify_observers(&nodeComponent->onSceneTreeExit, &(SkaSubjectNotifyPayload) { -// .data = &entity -// }); -// } } void ska_ecs_system_event_entity_entered_scene(SkaEntity entity) { - // Notify scene enter observers before calling it on systems -// NodeComponent* nodeComponent = (NodeComponent*) ska_ecs_component_manager_get_component_unchecked(entity, CreComponentDataIndex_NODE); -// if (nodeComponent != NULL) { -// ska_event_notify_observers(&nodeComponent->onSceneTreeEnter, &(SkaSubjectNotifyPayload) { -// .data = &entity -// }); -// } const SkaComponentType entityComponentSignature = ska_ecs_component_manager_get_component_signature(entity); for (usize i = 0; i < entitySystemData.on_entity_entered_scene_systems_count; i++) { SkaECSSystem* ecsSystem = entitySystemData.on_entity_entered_scene_systems[i]; @@ -274,19 +260,21 @@ void ska_ecs_system_event_network_callback(const char* message) { } } -// --- Internal Functions --- // bool ska_ecs_system_has_entity(SkaEntity entity, SkaECSSystem* system) { - for (usize i = 0; i < system->entity_count; i++) { - if (entity == system->entities[i]) { - return true; - } + return ska_array_list_has(system->entities, &entity); +} + +void ska_ecs_system_remove_entity_from_all_systems(SkaEntity entity) { + for (usize i = 0; i < entitySystemData.entity_systems_count; i++) { + ska_ecs_system_remove_entity_from_system(entity, entitySystemData.entity_systems[i]); } - return false; } +// --- Internal Functions --- // + void ska_ecs_system_insert_entity_into_system(SkaEntity entity, SkaECSSystem* system) { if (!ska_ecs_system_has_entity(entity, system)) { - system->entities[system->entity_count++] = entity; + ska_array_list_push_back(system->entities, &entity); if (system->on_entity_registered_func != NULL) { system->on_entity_registered_func(system, entity); } @@ -296,36 +284,5 @@ void ska_ecs_system_insert_entity_into_system(SkaEntity entity, SkaECSSystem* sy } void ska_ecs_system_remove_entity_from_system(SkaEntity entity, SkaECSSystem* system) { - for (usize i = 0; i < system->entity_count; i++) { - if (entity == system->entities[i]) { - // Entity found - if (i + 1 < SKA_MAX_ENTITIES) { - system->entities[i] = SKA_NULL_ENTITY; - } - if (system->on_entity_unregistered_func != NULL) { - system->on_entity_unregistered_func(system, entity); - } - - // Condense array - for (usize newIndex = i; i < system->entity_count; i++) { - if (system->entities[i] == SKA_NULL_ENTITY) { - // Early exit if 2 consecutive nulls - if (system->entities[i + 1] == SKA_NULL_ENTITY) { - break; - } - system->entities[i] = system->entities[i + 1]; - system->entities[i + 1] = SKA_NULL_ENTITY; - } - } - - system->entity_count--; - break; - } - } -} - -void ska_ecs_system_remove_entity_from_all_systems(SkaEntity entity) { - for (usize i = 0; i < entitySystemData.entity_systems_count; i++) { - ska_ecs_system_remove_entity_from_system(entity, entitySystemData.entity_systems[i]); - } -} + ska_array_list_remove(system->entities, &entity); +} \ No newline at end of file diff --git a/seika1/ecs/ec_system.h b/seika1/ecs/ec_system.h index 98ba3cb..4078c92 100644 --- a/seika1/ecs/ec_system.h +++ b/seika1/ecs/ec_system.h @@ -1,6 +1,7 @@ #pragma once #include "component.h" +#include "seika1/data_structures/array_list.h" #define SKA_ECS_SYSTEM_CREATE(NAME, ...) \ ska_ecs_system_create_with_signature_string(NAME, #__VA_ARGS__) @@ -12,6 +13,8 @@ ska_ecs_system_create_from_template_with_signature_string(TEMPLATE, #__VA_ARGS__ #define SKA_ECS_SYSTEM_REGISTER_FROM_TEMPLATE(TEMPLATE, ...) \ ska_ecs_system_register(ska_ecs_system_create_from_template_with_signature_string(TEMPLATE, #__VA_ARGS__)) +#define SKA_ECS_SYSTEM_ENTITIES_FOR(SYSTEM, VALUE) SKA_ARRAY_LIST_FOR_EACH(SYSTEM->list, SkaEntity, VALUE) + struct SkaECSSystem; typedef void (*OnECSystemRegister) (struct SkaECSSystem*); @@ -45,9 +48,7 @@ typedef struct SkaECSSystem { FixedUpdateFunc fixed_update_func; NetworkCallbackFunc network_callback_func; SkaComponentType component_signature; - usize entity_count; - // Keeps track of entities that match a component signature - SkaEntity entities[SKA_MAX_ENTITIES]; + SkaArrayList* entities; } SkaECSSystem; typedef struct SkaECSSystemTemplate { diff --git a/seika1/ecs/ecs.h b/seika1/ecs/ecs.h index 7b7e0a0..4a8444f 100644 --- a/seika1/ecs/ecs.h +++ b/seika1/ecs/ecs.h @@ -1,5 +1,6 @@ #pragma once +// Including ecs related headers to simplify includes #include "ec_system.h" void ska_ecs_initialize(); diff --git a/seika1/ecs/entity.c b/seika1/ecs/entity.c index 013b128..bc7e799 100644 --- a/seika1/ecs/entity.c +++ b/seika1/ecs/entity.c @@ -1,40 +1,35 @@ #include "entity.h" -#include "seika/data_structures/queue.h" -#include "seika/assert.h" +#include "seika1/data_structures/id_queue.h" +#include "seika1/assert.h" + +#define SKA_INITIAL_ENTITY_CAPACITY 1000 static SkaIdQueue* entityIdQueue = NULL; -static SkaEntity entityIdCounter = 0; static usize activeEntityCount = 0; void ska_ecs_entity_initialize() { SKA_ASSERT(entityIdQueue == NULL); - entityIdQueue = ska_queue_create(SKA_MAX_ENTITIES, SKA_NULL_ENTITY); - while (entityIdCounter < 100) { - ska_queue_enqueue(entityIdQueue, entityIdCounter++); - } + entityIdQueue = ska_id_queue_create(SKA_INITIAL_ENTITY_CAPACITY); } void ska_ecs_entity_finalize() { SKA_ASSERT(entityIdQueue); - ska_queue_destroy(entityIdQueue); + ska_id_queue_destroy(entityIdQueue); entityIdQueue = NULL; - entityIdCounter = 0; activeEntityCount = 0; } SkaEntity ska_ecs_entity_create() { SKA_ASSERT(entityIdQueue); - if (ska_queue_is_empty(entityIdQueue)) { - SKA_ASSERT_FMT(entityIdCounter < SKA_MAX_ENTITIES, "Reached maxed entities ids to create, considering increasing SKA_MAX_ENTITIES!"); - ska_queue_enqueue(entityIdQueue, entityIdCounter++); - } + SkaEntity newEntity; + ska_id_queue_dequeue(entityIdQueue, &newEntity); activeEntityCount++; - return ska_queue_dequeue(entityIdQueue); + return newEntity; } void ska_ecs_entity_return(SkaEntity entity) { SKA_ASSERT(entityIdQueue); - ska_queue_enqueue(entityIdQueue,entity); + ska_id_queue_enqueue(entityIdQueue, entity); activeEntityCount--; } diff --git a/seika1/ecs/entity.h b/seika1/ecs/entity.h index ec958b0..3b1a4a4 100644 --- a/seika1/ecs/entity.h +++ b/seika1/ecs/entity.h @@ -1,19 +1,10 @@ #pragma once -#include - -#include "seika/defines.h" +#include "seika1/defines.h" // Entity is defined as a unsigned 32-bit integer - -// Gives a chance for users to set own max entities -#ifndef SKA_MAX_ENTITIES -#define SKA_MAX_ENTITIES 200000 // starting with 200,000 for now -#endif - -#define SKA_NULL_ENTITY UINT32_MAX - typedef uint32 SkaEntity; +#define SKA_NULL_ENTITY (SkaEntity)0 void ska_ecs_entity_initialize(); void ska_ecs_entity_finalize(); From 8354db4a4e85b6cf05ab3788facf098ed9588de4 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 17 Oct 2024 15:47:19 -0400 Subject: [PATCH 13/55] Clean. --- seika1/ecs/component.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/seika1/ecs/component.c b/seika1/ecs/component.c index 0a9bec3..733a139 100644 --- a/seika1/ecs/component.c +++ b/seika1/ecs/component.c @@ -124,6 +124,10 @@ void* ska_ecs_component_manager_get_component_unchecked(SkaEntity entity, SkaCom } void ska_ecs_component_manager_set_component(SkaEntity entity, SkaComponentIndex index, void* component) { + // Add to component array if entity exceeds size + if ((usize)entity >= componentManager.componentArrays->size) { + ska_array_list_push_back(componentManager.componentArrays, &entity); + } ComponentArray* componentArray = ska_array_list_get(componentManager.componentArrays, (usize)entity); component_array_set_component(componentArray, index, component); componentArray->signature |= component_manager_translate_index_to_type(index); From 76f74bd1edf4bf79efda0bda8020705bc1fa7535 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 17 Oct 2024 15:57:37 -0400 Subject: [PATCH 14/55] Clean.: --- seika1/ecs/component.c | 10 ++++ seika1/ecs/ec_system.c | 16 +++--- seika1/flag_utils.h | 24 +++++++++ seika1/logger.c | 4 +- test/test1.c | 107 +++++++++++++++++++++++++++++++++++++++++ 5 files changed, 150 insertions(+), 11 deletions(-) create mode 100644 seika1/flag_utils.h diff --git a/seika1/ecs/component.c b/seika1/ecs/component.c index 733a139..18726ea 100644 --- a/seika1/ecs/component.c +++ b/seika1/ecs/component.c @@ -149,6 +149,16 @@ bool ska_ecs_component_manager_has_component(SkaEntity entity, SkaComponentIndex return component_array_has_component(componentArray, index); } +void ska_ecs_component_manager_set_component_signature(SkaEntity entity, SkaComponentType componentTypeSignature) { + ComponentArray* componentArray = ska_array_list_get(componentManager.componentArrays, (usize)entity); + componentArray->signature = componentTypeSignature; +} + +SkaComponentType ska_ecs_component_manager_get_component_signature(SkaEntity entity) { + const ComponentArray* componentArray = ska_array_list_get(componentManager.componentArrays, (usize)entity); + return componentArray->signature; +} + SkaComponentType component_manager_translate_index_to_type(SkaComponentIndex index) { SKA_STRING_HASH_MAP_FOR_EACH(componentNameToTypeMap, iter) { SkaStringHashMapNode* node = iter.pair; diff --git a/seika1/ecs/ec_system.c b/seika1/ecs/ec_system.c index 2b1b0eb..0381110 100644 --- a/seika1/ecs/ec_system.c +++ b/seika1/ecs/ec_system.c @@ -1,12 +1,10 @@ #include "ec_system.h" -#include - -#include "seika/string.h" -#include "seika/flag_utils.h" -#include "seika/logger.h" -#include "seika/memory.h" -#include "seika/assert.h" +#include "seika1/string.h" +#include "seika1/flag_utils.h" +#include "seika1/logger.h" +#include "seika1/memory.h" +#include "seika1/assert.h" //--- EC System Manager ---// #define MAX_ENTITY_SYSTEMS_PER_HOOK 12 @@ -52,7 +50,7 @@ void ska_ecs_system_finalize() { } SkaECSSystem* ska_ecs_system_create(const char* systemName) { - SkaECSSystem* newSystem = SKA_MEM_ALLOCATE(SkaECSSystem); + SkaECSSystem* newSystem = SKA_ALLOC_ZEROED(SkaECSSystem); newSystem->name = ska_strdup(systemName); newSystem->entities = ska_array_list_create_default_capacity(sizeof(SkaEntity)); return newSystem; @@ -127,7 +125,7 @@ void ska_ecs_system_destroy(SkaECSSystem* entitySystem) { if (entitySystem->on_ec_system_destroy) { entitySystem->on_ec_system_destroy(entitySystem); } - SKA_MEM_FREE(entitySystem); + SKA_FREE(entitySystem); } void ska_ecs_system_register(SkaECSSystem* system) { diff --git a/seika1/flag_utils.h b/seika1/flag_utils.h new file mode 100644 index 0000000..abef55e --- /dev/null +++ b/seika1/flag_utils.h @@ -0,0 +1,24 @@ +#pragma once + +// Contains flag macros... + +// Check if 'FLAGS' contains all the flags specified in 'REQUIRED_FLAGS' +#define SKA_FLAG_CONTAINS(FLAGS, REQUIRED_FLAGS) (((FLAGS) & (REQUIRED_FLAGS)) == (REQUIRED_FLAGS)) + +// Check if 'FLAG' contains any of the flags specified in 'REQUIRED_FLAGS' +#define SKA_HAS_FLAG(FLAG, REQUIRED_FLAGS) ((FLAG) & (REQUIRED_FLAGS)) + +// Check if 'FLAGS' contains none of the flags specified in 'FORBIDDEN_FLAGS' +#define SKA_HAS_NO_FLAG(FLAGS, FORBIDDEN_FLAGS) (((FLAGS) & (FORBIDDEN_FLAGS)) == 0) + +// Check if 'FLAGS' contains exactly one of the flags specified in 'REQUIRED_FLAGS' +#define SKA_HAS_EXACTLY_ONE_FLAG(FLAGS, REQUIRED_FLAGS) (HAS_ALL_FLAGS(FLAGS, REQUIRED_FLAGS) && ((FLAGS) != 0)) + +// Check if 'FLAGS' contains none of the flags specified in 'REQUIRED_FLAGS' +#define SKA_HAS_NONE_OF_FLAGS(FLAGS, REQUIRED_FLAGS) (((FLAGS) & (REQUIRED_FLAGS)) == 0) + +// Add 'NEW_FLAGS' to 'FLAGS' +#define SKA_ADD_FLAGS(FLAGS, NEW_FLAGS) ((FLAGS) |= (NEW_FLAGS)) + +// Remove 'REMOVE_FLAGS' from 'FLAGS' +#define SKA_REMOVE_FLAGS(FLAGS, REMOVE_FLAGS) ((FLAGS) &= ~(REMOVE_FLAGS)) diff --git a/seika1/logger.c b/seika1/logger.c index 279bd6b..9e92f2f 100644 --- a/seika1/logger.c +++ b/seika1/logger.c @@ -105,7 +105,7 @@ void ska_logger_internal_queue_message(const char* fmt, ...) { queuedLogMessagesCount++; } // Freeing in case we looped around - SKA_MEM_FREE(queuedLogMessages[currentIndex]); + SKA_FREE(queuedLogMessages[currentIndex]); queuedLogMessages[currentIndex] = ska_strdup(str); } va_end(args); @@ -115,7 +115,7 @@ bool ska_logger_internal_print_queue() { if (queuedLogMessagesCount > 0) { for (usize i = 0; i < queuedLogMessagesCount; i++) { ska_logger_message(queuedLogMessages[i]); - SKA_MEM_FREE(queuedLogMessages[i]); + SKA_FREE(queuedLogMessages[i]); queuedLogMessages[i] = NULL; } queuedLogMessagesCount = 0; diff --git a/test/test1.c b/test/test1.c index c6a46c7..ab3a72d 100644 --- a/test/test1.c +++ b/test/test1.c @@ -4,6 +4,9 @@ #include "seika1/memory.h" #include "seika1/data_structures/array_list.h" #include "seika1/data_structures/id_queue.h" +#include "seika1/ecs/ecs.h" +#include "seika1/ecs/ec_system.h" +#include "seika1/math/math.h" #define RESOURCES_PATH "test/resources" #define RESOURCES_PACK_PATH "test/resources/test.pck" @@ -15,11 +18,18 @@ void seika_mem_test(void); void seika_array_list_test(void); void seika_id_queue_test(void); +#if SKA_ECS +void seika_ecs_test(void); +#endif + int32 main(int32 argv, char** args) { UNITY_BEGIN(); RUN_TEST(seika_mem_test); RUN_TEST(seika_array_list_test); RUN_TEST(seika_id_queue_test); +#if SKA_ECS + RUN_TEST(seika_ecs_test); +#endif return UNITY_END(); } @@ -88,3 +98,100 @@ void seika_id_queue_test(void) { TEST_ASSERT_EQUAL_UINT32(10, value); TEST_ASSERT_EQUAL_size_t(20, idQueue->capacity); } + +#if SKA_ECS +typedef struct TestValueComponent { + int32 value; +} TestValueComponent; + +typedef struct TestTransformComponent { + SkaTransform2D transform2D; +} TestTransformComponent; + +// test ecs callbacks + +static int32 entityRegisteredInTestCount = 0; +void test_ecs_callback_on_entity_registered(SkaECSSystem* system, SkaEntity entity){ + entityRegisteredInTestCount++; +} + +void seika_ecs_test(void) { + ska_ecs_initialize(); + + SKA_ECS_REGISTER_COMPONENT(TestValueComponent); + SKA_ECS_REGISTER_COMPONENT(TestTransformComponent); + + // Test getting component type info + const SkaComponentTypeInfo* valueTypeInfo = SKA_ECS_COMPONENT_TYPE_INFO(TestValueComponent); + TEST_ASSERT_NOT_NULL(valueTypeInfo); + TEST_ASSERT_EQUAL_STRING("TestValueComponent", valueTypeInfo->name); + TEST_ASSERT_EQUAL_INT(1 << 0, valueTypeInfo->type); + TEST_ASSERT_EQUAL_UINT32(0, valueTypeInfo->index); + TEST_ASSERT_EQUAL_size_t(sizeof(TestValueComponent), valueTypeInfo->size); + const SkaComponentTypeInfo* transformTypeInfo = SKA_ECS_COMPONENT_TYPE_INFO(TestTransformComponent); + TEST_ASSERT_NOT_NULL(transformTypeInfo); + TEST_ASSERT_EQUAL_STRING("TestTransformComponent", transformTypeInfo->name); + TEST_ASSERT_EQUAL_INT(1 << 1, transformTypeInfo->type); + TEST_ASSERT_EQUAL_UINT32(1, transformTypeInfo->index); + TEST_ASSERT_EQUAL_size_t(sizeof(TestTransformComponent), transformTypeInfo->size); + + // Test creating ecs system + const SkaEntity testEntity = ska_ecs_entity_create(); + + SkaECSSystem* testValueEcsSystem = SKA_ECS_SYSTEM_CREATE("test value system", TestValueComponent); + testValueEcsSystem->on_entity_registered_func = test_ecs_callback_on_entity_registered; + ska_ecs_system_register(testValueEcsSystem); + + // Test creating with template +#define VALUE_TRANSFORM_SYSTEM_TEMPLATE &(SkaECSSystemTemplate){ \ + .name = "test value transform system", \ + .on_ec_system_register = NULL, \ + .on_ec_system_destroy = NULL, \ + .on_entity_registered_func = test_ecs_callback_on_entity_registered, \ + .on_entity_start_func = NULL, \ + .on_entity_end_func = NULL, \ + .on_entity_unregistered_func = NULL, \ + .on_entity_entered_scene_func = NULL, \ + .render_func = NULL, \ + .pre_update_all_func = NULL, \ + .post_update_all_func = NULL, \ + .update_func = NULL, \ + .fixed_update_func = NULL, \ + .network_callback_func = NULL \ +} + SKA_ECS_SYSTEM_REGISTER_FROM_TEMPLATE(VALUE_TRANSFORM_SYSTEM_TEMPLATE, TestValueComponent, TestTransformComponent); +#undef VALUE_TRANSFORM_SYSTEM_TEMPLATE + + // Test entity id enqueue and dequeue +#define TEST_ENTITY_QUEUE_AMOUNT 1000 + for (SkaEntity entity = 1; entity < TEST_ENTITY_QUEUE_AMOUNT; entity++) { + const SkaEntity newEntity = ska_ecs_entity_create(); + TEST_ASSERT_EQUAL_UINT32(entity, newEntity); + } + TEST_ASSERT_EQUAL_size_t(TEST_ENTITY_QUEUE_AMOUNT, ska_ecs_entity_get_active_count()); + for (SkaEntity entity = 1; entity < TEST_ENTITY_QUEUE_AMOUNT; entity++) { + ska_ecs_entity_return(entity); + } + TEST_ASSERT_EQUAL_size_t(1, ska_ecs_entity_get_active_count()); +#undef TEST_ENTITY_QUEUE_AMOUNT + + // Test getting component + TestValueComponent testComponent = { .value = 10 }; + ska_ecs_component_manager_set_component(testEntity, valueTypeInfo->index, &testComponent); + TestValueComponent* returnedValueComponent = (TestValueComponent*)ska_ecs_component_manager_get_component(testEntity, valueTypeInfo->index); + TEST_ASSERT_NOT_NULL(returnedValueComponent); + TEST_ASSERT_EQUAL_INT(10, returnedValueComponent->value); + TestTransformComponent transformComponent = { .transform2D = { .position = { .x = 10.0f, .y = 20.0f}, .scale = SKA_VECTOR2_ONE, .rotation = 0.0f } }; + ska_ecs_component_manager_set_component(testEntity, transformTypeInfo->index, &transformComponent); + TestTransformComponent* returnedTransformComponent = (TestTransformComponent*)ska_ecs_component_manager_get_component(testEntity, transformTypeInfo->index); + TEST_ASSERT_NOT_NULL(returnedTransformComponent); + TEST_ASSERT_EQUAL_FLOAT(10.0f, returnedTransformComponent->transform2D.position.x); + TEST_ASSERT_EQUAL_FLOAT(20.0f, returnedTransformComponent->transform2D.position.y); + + // Test component events + ska_ecs_system_update_entity_signature_with_systems(testEntity); + TEST_ASSERT_EQUAL_INT(2, entityRegisteredInTestCount); + + ska_ecs_finalize(); +} +#endif From 489b91b8fbb6253b21e14ad0f4652732598771e6 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 17 Oct 2024 22:47:27 -0400 Subject: [PATCH 15/55] Updates. --- CMakeLists.txt | 27 +++++++++++++-------------- seika1/data_structures/hash_map.c | 8 ++++---- seika1/ecs/component.c | 4 ++++ seika1/ecs/component.h | 4 ++++ seika1/ecs/ec_system.c | 6 +++++- seika1/ecs/ec_system.h | 4 ++++ seika1/ecs/ecs.c | 4 ++++ seika1/ecs/ecs.h | 4 ++++ seika1/ecs/entity.c | 4 ++++ seika1/ecs/entity.h | 4 ++++ test/test1.c | 5 ++++- 11 files changed, 54 insertions(+), 20 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 0587fdc..27fab80 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -10,24 +10,22 @@ option(SEIKA_ENABLE_OLD "Will build old seika lib" OFF) option(SEIKA_ENABLE_1 "Will build new seika lib" ON) # Compilation Modes -option(SEIKA_ENABLE_ECS "Will enable ecs" OFF) +option(SEIKA_ENABLE_ECS "Will enable ecs" ON) option(SEIKA_ENABLE_INPUT "Will enable input" OFF) option(SEIKA_ENABLE_RENDERING "Will enable rendering" OFF) option(SEIKA_ENABLE_AUDIO "Will enable audio" OFF) -# Since everything is enabled by default, we only disable modules -if (!SEIKA_ENABLE_ECS) - add_compile_definitions(SKA_ECS=0) -endif() -if (!SEIKA_ENABLE_INPUT) - add_compile_definitions(SKA_INPUT=0) -endif() -if (!SEIKA_ENABLE_RENDERING) - add_compile_definitions(SKA_RENDERING=0) -endif() -if (!SEIKA_ENABLE_AUDIO) - add_compile_definitions(SKA_AUDIO=0) -endif() +add_compile_definitions(SKA_ECS=$,1,0>) +add_compile_definitions(SKA_INPUT=$,1,0>) +add_compile_definitions(SKA_RENDERING=$,1,0>) +add_compile_definitions(SKA_AUDIO=$,1,0>) + +function(set_common_compile_definitions target) + target_compile_definitions(${target} PRIVATE SKA_ECS=$,1,0>) + target_compile_definitions(${target} PRIVATE SKA_INPUT=$,1,0>) + target_compile_definitions(${target} PRIVATE SKA_RENDERING=$,1,0>) + target_compile_definitions(${target} PRIVATE SKA_AUDIO=$,1,0>) +endfunction() set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) @@ -58,5 +56,6 @@ if (SK_IS_MAIN) # Create seika1 test exe add_executable(seika1_test test/test1.c) target_link_libraries(seika1_test seika1 unity) + set_common_compile_definitions(seika1_test) endif() endif() diff --git a/seika1/data_structures/hash_map.c b/seika1/data_structures/hash_map.c index a1dd002..204ad4b 100644 --- a/seika1/data_structures/hash_map.c +++ b/seika1/data_structures/hash_map.c @@ -183,7 +183,7 @@ void hash_map_resize(SkaHashMap* hashMap, usize capacity) { hash_map_rehash(hashMap, oldNode, oldCapacity); - SKA_MEM_FREE(oldNode); + SKA_FREE(oldNode); } // --- Iterator --- // @@ -256,9 +256,9 @@ void hash_map_destroy_node(SkaHashMapNode* node) { SKA_ASSERT(node->value != NULL); SKA_ASSERT(node->key != NULL); - SKA_MEM_FREE(node->key); + SKA_FREE(node->key); node->key = NULL; - SKA_MEM_FREE(node->value); + SKA_FREE(node->value); node->value = NULL; - SKA_MEM_FREE(node); + SKA_FREE(node); } diff --git a/seika1/ecs/component.c b/seika1/ecs/component.c index 18726ea..862c789 100644 --- a/seika1/ecs/component.c +++ b/seika1/ecs/component.c @@ -1,3 +1,5 @@ +#if SKA_ECS + #include "component.h" #include "seika1/string.h" @@ -180,3 +182,5 @@ const char* ska_ecs_component_get_component_data_index_string(SkaComponentIndex } return "INVALID"; } + +#endif // if SKA_ECS diff --git a/seika1/ecs/component.h b/seika1/ecs/component.h index 5057b84..d2562a1 100644 --- a/seika1/ecs/component.h +++ b/seika1/ecs/component.h @@ -1,5 +1,7 @@ #pragma once +#if SKA_ECS + #ifdef __cplusplus extern "C" { #endif @@ -52,3 +54,5 @@ const char* ska_ecs_component_get_component_data_index_string(SkaComponentIndex #ifdef __cplusplus } #endif + +#endif // if SKA_ECS diff --git a/seika1/ecs/ec_system.c b/seika1/ecs/ec_system.c index 0381110..986f469 100644 --- a/seika1/ecs/ec_system.c +++ b/seika1/ecs/ec_system.c @@ -1,3 +1,5 @@ +#if SKA_ECS + #include "ec_system.h" #include "seika1/string.h" @@ -283,4 +285,6 @@ void ska_ecs_system_insert_entity_into_system(SkaEntity entity, SkaECSSystem* sy void ska_ecs_system_remove_entity_from_system(SkaEntity entity, SkaECSSystem* system) { ska_array_list_remove(system->entities, &entity); -} \ No newline at end of file +} + +#endif // if SKA_ECS diff --git a/seika1/ecs/ec_system.h b/seika1/ecs/ec_system.h index 4078c92..2d0f304 100644 --- a/seika1/ecs/ec_system.h +++ b/seika1/ecs/ec_system.h @@ -1,5 +1,7 @@ #pragma once +#if SKA_ECS + #include "component.h" #include "seika1/data_structures/array_list.h" @@ -109,3 +111,5 @@ void ska_ecs_system_event_post_update_all_systems(); void ska_ecs_system_event_update_systems(f32 deltaTime); void ska_ecs_system_event_fixed_update_systems(f32 deltaTime); void ska_ecs_system_event_network_callback(const char* message); + +#endif // if SKA_ECS diff --git a/seika1/ecs/ecs.c b/seika1/ecs/ecs.c index e269fe2..472e53a 100644 --- a/seika1/ecs/ecs.c +++ b/seika1/ecs/ecs.c @@ -1,3 +1,5 @@ +#if SKA_ECS + #include "ecs.h" void ska_ecs_initialize() { @@ -11,3 +13,5 @@ void ska_ecs_finalize() { ska_ecs_component_manager_finalize(); ska_ecs_system_finalize(); } + +#endif // if SKA_ECS diff --git a/seika1/ecs/ecs.h b/seika1/ecs/ecs.h index 4a8444f..ad44c8a 100644 --- a/seika1/ecs/ecs.h +++ b/seika1/ecs/ecs.h @@ -1,7 +1,11 @@ #pragma once +#if SKA_ECS + // Including ecs related headers to simplify includes #include "ec_system.h" void ska_ecs_initialize(); void ska_ecs_finalize(); + +#endif // if SKA_ECS \ No newline at end of file diff --git a/seika1/ecs/entity.c b/seika1/ecs/entity.c index bc7e799..3d63ddc 100644 --- a/seika1/ecs/entity.c +++ b/seika1/ecs/entity.c @@ -1,3 +1,5 @@ +#if SKA_ECS + #include "entity.h" #include "seika1/data_structures/id_queue.h" #include "seika1/assert.h" @@ -36,3 +38,5 @@ void ska_ecs_entity_return(SkaEntity entity) { usize ska_ecs_entity_get_active_count() { return activeEntityCount; } + +#endif // if SKA_ECS diff --git a/seika1/ecs/entity.h b/seika1/ecs/entity.h index 3b1a4a4..dcd8d89 100644 --- a/seika1/ecs/entity.h +++ b/seika1/ecs/entity.h @@ -1,5 +1,7 @@ #pragma once +#if SKA_ECS + #include "seika1/defines.h" // Entity is defined as a unsigned 32-bit integer @@ -13,3 +15,5 @@ SkaEntity ska_ecs_entity_create(); // Push entity to the queue void ska_ecs_entity_return(SkaEntity entity); usize ska_ecs_entity_get_active_count(); + +#endif // if SKA_ECS diff --git a/test/test1.c b/test/test1.c index ab3a72d..608aac9 100644 --- a/test/test1.c +++ b/test/test1.c @@ -4,9 +4,12 @@ #include "seika1/memory.h" #include "seika1/data_structures/array_list.h" #include "seika1/data_structures/id_queue.h" +#include "seika1/math/math.h" + +#if SKA_ECS #include "seika1/ecs/ecs.h" #include "seika1/ecs/ec_system.h" -#include "seika1/math/math.h" +#endif #define RESOURCES_PATH "test/resources" #define RESOURCES_PACK_PATH "test/resources/test.pck" From 2b7b94523ec0ce97131e141fa9eb6dcbce306b75 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 17 Oct 2024 22:48:38 -0400 Subject: [PATCH 16/55] Clean. --- seika1/defines.h | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/seika1/defines.h b/seika1/defines.h index dca0060..f0e4718 100644 --- a/seika1/defines.h +++ b/seika1/defines.h @@ -10,24 +10,6 @@ extern "C" { #include "seika1/version_info.h" -// Compilation modes - -#ifndef SKA_ECS -#define SKA_ECS 1 -#endif - -#ifndef SKA_INPUT -#define SKA_INPUT 1 -#endif - -#ifndef SKA_RENDERING -#define SKA_RENDERING 1 -#endif - -#ifndef SKA_AUDIO -#define SKA_AUDIO 1 -#endif - typedef size_t usize; typedef int16_t int16; From 5a288f2bcc40f8ac65f6ee366b02fae4f6c5e35b Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 17 Oct 2024 22:52:04 -0400 Subject: [PATCH 17/55] Renaming seika to old seika. --- CMakeLists.txt | 4 ++-- README.md | 7 ++++--- {seika => old_seika}/CMakeLists.txt | 0 {seika => old_seika}/assert.c | 0 {seika => old_seika}/assert.h | 0 {seika => old_seika}/asset/asset_file_loader.c | 0 {seika => old_seika}/asset/asset_file_loader.h | 0 {seika => old_seika}/asset/asset_manager.c | 0 {seika => old_seika}/asset/asset_manager.h | 0 {seika => old_seika}/audio/audio.c | 0 {seika => old_seika}/audio/audio.h | 0 {seika => old_seika}/audio/audio_manager.c | 0 {seika => old_seika}/audio/audio_manager.h | 0 {seika => old_seika}/command_line_args_util.c | 0 {seika => old_seika}/command_line_args_util.h | 0 {seika => old_seika}/data_structures/array2d.c | 0 {seika => old_seika}/data_structures/array2d.h | 0 {seika => old_seika}/data_structures/array_list.c | 0 {seika => old_seika}/data_structures/array_list.h | 0 {seika => old_seika}/data_structures/array_utils.c | 0 {seika => old_seika}/data_structures/array_utils.h | 0 {seika => old_seika}/data_structures/hash_map.c | 0 {seika => old_seika}/data_structures/hash_map.h | 0 {seika => old_seika}/data_structures/hash_map_string.c | 0 {seika => old_seika}/data_structures/hash_map_string.h | 0 {seika => old_seika}/data_structures/linked_list.c | 0 {seika => old_seika}/data_structures/linked_list.h | 0 {seika => old_seika}/data_structures/queue.c | 0 {seika => old_seika}/data_structures/queue.h | 0 {seika => old_seika}/data_structures/spatial_hash_map.c | 0 {seika => old_seika}/data_structures/spatial_hash_map.h | 0 {seika => old_seika}/data_structures/static_array.h | 0 {seika => old_seika}/data_structures/tile_map.h | 0 {seika => old_seika}/defines.h | 0 {seika => old_seika}/ecs/component.c | 0 {seika => old_seika}/ecs/component.h | 0 {seika => old_seika}/ecs/ec_system.c | 0 {seika => old_seika}/ecs/ec_system.h | 0 {seika => old_seika}/ecs/ecs.c | 0 {seika => old_seika}/ecs/ecs.h | 0 {seika => old_seika}/ecs/entity.c | 0 {seika => old_seika}/ecs/entity.h | 0 {seika => old_seika}/event.c | 0 {seika => old_seika}/event.h | 0 {seika => old_seika}/file_system.c | 0 {seika => old_seika}/file_system.h | 0 {seika => old_seika}/flag_utils.h | 0 {seika => old_seika}/input/input.c | 0 {seika => old_seika}/input/input.h | 0 {seika => old_seika}/input/sdl_gamepad_db.h | 0 {seika => old_seika}/input/sdl_input.h | 0 {seika => old_seika}/logger.c | 0 {seika => old_seika}/logger.h | 0 {seika => old_seika}/macro_utils.h | 0 {seika => old_seika}/math/curve_float.c | 0 {seika => old_seika}/math/curve_float.h | 0 {seika => old_seika}/math/math.c | 0 {seika => old_seika}/math/math.h | 0 {seika => old_seika}/memory.c | 0 {seika => old_seika}/memory.h | 0 {seika => old_seika}/networking/network.c | 0 {seika => old_seika}/networking/network.h | 0 {seika => old_seika}/networking/network_socket.c | 0 {seika => old_seika}/networking/network_socket.h | 0 {seika => old_seika}/platform.c | 0 {seika => old_seika}/platform.h | 0 {seika => old_seika}/profile_code.h | 0 {seika => old_seika}/rendering/font.c | 0 {seika => old_seika}/rendering/font.h | 0 {seika => old_seika}/rendering/frame_buffer.c | 0 {seika => old_seika}/rendering/frame_buffer.h | 0 {seika => old_seika}/rendering/render_context.c | 0 {seika => old_seika}/rendering/render_context.h | 0 {seika => old_seika}/rendering/renderer.c | 0 {seika => old_seika}/rendering/renderer.h | 0 {seika => old_seika}/rendering/shader/shader.c | 0 {seika => old_seika}/rendering/shader/shader.h | 0 {seika => old_seika}/rendering/shader/shader_cache.c | 0 {seika => old_seika}/rendering/shader/shader_cache.h | 0 {seika => old_seika}/rendering/shader/shader_file_parser.c | 0 {seika => old_seika}/rendering/shader/shader_file_parser.h | 0 {seika => old_seika}/rendering/shader/shader_instance.c | 0 {seika => old_seika}/rendering/shader/shader_instance.h | 0 .../rendering/shader/shader_instance_minimal.h | 0 {seika => old_seika}/rendering/shader/shader_source.h | 0 {seika => old_seika}/rendering/texture.c | 0 {seika => old_seika}/rendering/texture.h | 0 {seika => old_seika}/seika.c | 0 {seika => old_seika}/seika.h | 0 {seika => old_seika}/string.c | 0 {seika => old_seika}/string.h | 0 {seika => old_seika}/thread/pthread.c | 0 {seika => old_seika}/thread/pthread.h | 0 {seika => old_seika}/thread/thread_pool.c | 0 {seika => old_seika}/thread/thread_pool.h | 0 {seika => old_seika}/version_info.h | 0 seika1/logger.h | 2 +- seika1/memory.h | 2 +- seika1/version_info.h | 2 +- 99 files changed, 9 insertions(+), 8 deletions(-) rename {seika => old_seika}/CMakeLists.txt (100%) rename {seika => old_seika}/assert.c (100%) rename {seika => old_seika}/assert.h (100%) rename {seika => old_seika}/asset/asset_file_loader.c (100%) rename {seika => old_seika}/asset/asset_file_loader.h (100%) rename {seika => old_seika}/asset/asset_manager.c (100%) rename {seika => old_seika}/asset/asset_manager.h (100%) rename {seika => old_seika}/audio/audio.c (100%) rename {seika => old_seika}/audio/audio.h (100%) rename {seika => old_seika}/audio/audio_manager.c (100%) rename {seika => old_seika}/audio/audio_manager.h (100%) rename {seika => old_seika}/command_line_args_util.c (100%) rename {seika => old_seika}/command_line_args_util.h (100%) rename {seika => old_seika}/data_structures/array2d.c (100%) rename {seika => old_seika}/data_structures/array2d.h (100%) rename {seika => old_seika}/data_structures/array_list.c (100%) rename {seika => old_seika}/data_structures/array_list.h (100%) rename {seika => old_seika}/data_structures/array_utils.c (100%) rename {seika => old_seika}/data_structures/array_utils.h (100%) rename {seika => old_seika}/data_structures/hash_map.c (100%) rename {seika => old_seika}/data_structures/hash_map.h (100%) rename {seika => old_seika}/data_structures/hash_map_string.c (100%) rename {seika => old_seika}/data_structures/hash_map_string.h (100%) rename {seika => old_seika}/data_structures/linked_list.c (100%) rename {seika => old_seika}/data_structures/linked_list.h (100%) rename {seika => old_seika}/data_structures/queue.c (100%) rename {seika => old_seika}/data_structures/queue.h (100%) rename {seika => old_seika}/data_structures/spatial_hash_map.c (100%) rename {seika => old_seika}/data_structures/spatial_hash_map.h (100%) rename {seika => old_seika}/data_structures/static_array.h (100%) rename {seika => old_seika}/data_structures/tile_map.h (100%) rename {seika => old_seika}/defines.h (100%) rename {seika => old_seika}/ecs/component.c (100%) rename {seika => old_seika}/ecs/component.h (100%) rename {seika => old_seika}/ecs/ec_system.c (100%) rename {seika => old_seika}/ecs/ec_system.h (100%) rename {seika => old_seika}/ecs/ecs.c (100%) rename {seika => old_seika}/ecs/ecs.h (100%) rename {seika => old_seika}/ecs/entity.c (100%) rename {seika => old_seika}/ecs/entity.h (100%) rename {seika => old_seika}/event.c (100%) rename {seika => old_seika}/event.h (100%) rename {seika => old_seika}/file_system.c (100%) rename {seika => old_seika}/file_system.h (100%) rename {seika => old_seika}/flag_utils.h (100%) rename {seika => old_seika}/input/input.c (100%) rename {seika => old_seika}/input/input.h (100%) rename {seika => old_seika}/input/sdl_gamepad_db.h (100%) rename {seika => old_seika}/input/sdl_input.h (100%) rename {seika => old_seika}/logger.c (100%) rename {seika => old_seika}/logger.h (100%) rename {seika => old_seika}/macro_utils.h (100%) rename {seika => old_seika}/math/curve_float.c (100%) rename {seika => old_seika}/math/curve_float.h (100%) rename {seika => old_seika}/math/math.c (100%) rename {seika => old_seika}/math/math.h (100%) rename {seika => old_seika}/memory.c (100%) rename {seika => old_seika}/memory.h (100%) rename {seika => old_seika}/networking/network.c (100%) rename {seika => old_seika}/networking/network.h (100%) rename {seika => old_seika}/networking/network_socket.c (100%) rename {seika => old_seika}/networking/network_socket.h (100%) rename {seika => old_seika}/platform.c (100%) rename {seika => old_seika}/platform.h (100%) rename {seika => old_seika}/profile_code.h (100%) rename {seika => old_seika}/rendering/font.c (100%) rename {seika => old_seika}/rendering/font.h (100%) rename {seika => old_seika}/rendering/frame_buffer.c (100%) rename {seika => old_seika}/rendering/frame_buffer.h (100%) rename {seika => old_seika}/rendering/render_context.c (100%) rename {seika => old_seika}/rendering/render_context.h (100%) rename {seika => old_seika}/rendering/renderer.c (100%) rename {seika => old_seika}/rendering/renderer.h (100%) rename {seika => old_seika}/rendering/shader/shader.c (100%) rename {seika => old_seika}/rendering/shader/shader.h (100%) rename {seika => old_seika}/rendering/shader/shader_cache.c (100%) rename {seika => old_seika}/rendering/shader/shader_cache.h (100%) rename {seika => old_seika}/rendering/shader/shader_file_parser.c (100%) rename {seika => old_seika}/rendering/shader/shader_file_parser.h (100%) rename {seika => old_seika}/rendering/shader/shader_instance.c (100%) rename {seika => old_seika}/rendering/shader/shader_instance.h (100%) rename {seika => old_seika}/rendering/shader/shader_instance_minimal.h (100%) rename {seika => old_seika}/rendering/shader/shader_source.h (100%) rename {seika => old_seika}/rendering/texture.c (100%) rename {seika => old_seika}/rendering/texture.h (100%) rename {seika => old_seika}/seika.c (100%) rename {seika => old_seika}/seika.h (100%) rename {seika => old_seika}/string.c (100%) rename {seika => old_seika}/string.h (100%) rename {seika => old_seika}/thread/pthread.c (100%) rename {seika => old_seika}/thread/pthread.h (100%) rename {seika => old_seika}/thread/thread_pool.c (100%) rename {seika => old_seika}/thread/thread_pool.h (100%) rename {seika => old_seika}/version_info.h (100%) diff --git a/CMakeLists.txt b/CMakeLists.txt index 27fab80..a856e85 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -34,7 +34,7 @@ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) include(Dependencies.cmake) if (SEIKA_ENABLE_OLD) - add_subdirectory(seika) + add_subdirectory(old_seika) endif() if (SEIKA_ENABLE_1) add_subdirectory(seika1) @@ -48,7 +48,7 @@ endif() if (SK_IS_MAIN) if (SEIKA_ENABLE_OLD) - # Create seika test exe + # Create old_seika test exe add_executable(seika_test test/test.c) target_link_libraries(seika_test seika unity) endif() diff --git a/README.md b/README.md index 735c4de..d42c320 100644 --- a/README.md +++ b/README.md @@ -33,17 +33,18 @@ A framework for windows, macOS, and linux that can be used to make games. ## How to include in a project Seika uses cmake to build. To include in your project, add the following to your CMakeLists.txt: + ```cmake -# Include seika framework as a dependency +# Include old_seika framework as a dependency include(FetchContent) FetchContent_Declare( - seika + old_seika GIT_REPOSITORY https://github.com/Chukobyte/seika.git GIT_TAG v0.1.0 ) -FetchContent_MakeAvailable(seika) +FetchContent_MakeAvailable(old_seika) ``` Make sure to link seika to the target with `target_link_libraries`. diff --git a/seika/CMakeLists.txt b/old_seika/CMakeLists.txt similarity index 100% rename from seika/CMakeLists.txt rename to old_seika/CMakeLists.txt diff --git a/seika/assert.c b/old_seika/assert.c similarity index 100% rename from seika/assert.c rename to old_seika/assert.c diff --git a/seika/assert.h b/old_seika/assert.h similarity index 100% rename from seika/assert.h rename to old_seika/assert.h diff --git a/seika/asset/asset_file_loader.c b/old_seika/asset/asset_file_loader.c similarity index 100% rename from seika/asset/asset_file_loader.c rename to old_seika/asset/asset_file_loader.c diff --git a/seika/asset/asset_file_loader.h b/old_seika/asset/asset_file_loader.h similarity index 100% rename from seika/asset/asset_file_loader.h rename to old_seika/asset/asset_file_loader.h diff --git a/seika/asset/asset_manager.c b/old_seika/asset/asset_manager.c similarity index 100% rename from seika/asset/asset_manager.c rename to old_seika/asset/asset_manager.c diff --git a/seika/asset/asset_manager.h b/old_seika/asset/asset_manager.h similarity index 100% rename from seika/asset/asset_manager.h rename to old_seika/asset/asset_manager.h diff --git a/seika/audio/audio.c b/old_seika/audio/audio.c similarity index 100% rename from seika/audio/audio.c rename to old_seika/audio/audio.c diff --git a/seika/audio/audio.h b/old_seika/audio/audio.h similarity index 100% rename from seika/audio/audio.h rename to old_seika/audio/audio.h diff --git a/seika/audio/audio_manager.c b/old_seika/audio/audio_manager.c similarity index 100% rename from seika/audio/audio_manager.c rename to old_seika/audio/audio_manager.c diff --git a/seika/audio/audio_manager.h b/old_seika/audio/audio_manager.h similarity index 100% rename from seika/audio/audio_manager.h rename to old_seika/audio/audio_manager.h diff --git a/seika/command_line_args_util.c b/old_seika/command_line_args_util.c similarity index 100% rename from seika/command_line_args_util.c rename to old_seika/command_line_args_util.c diff --git a/seika/command_line_args_util.h b/old_seika/command_line_args_util.h similarity index 100% rename from seika/command_line_args_util.h rename to old_seika/command_line_args_util.h diff --git a/seika/data_structures/array2d.c b/old_seika/data_structures/array2d.c similarity index 100% rename from seika/data_structures/array2d.c rename to old_seika/data_structures/array2d.c diff --git a/seika/data_structures/array2d.h b/old_seika/data_structures/array2d.h similarity index 100% rename from seika/data_structures/array2d.h rename to old_seika/data_structures/array2d.h diff --git a/seika/data_structures/array_list.c b/old_seika/data_structures/array_list.c similarity index 100% rename from seika/data_structures/array_list.c rename to old_seika/data_structures/array_list.c diff --git a/seika/data_structures/array_list.h b/old_seika/data_structures/array_list.h similarity index 100% rename from seika/data_structures/array_list.h rename to old_seika/data_structures/array_list.h diff --git a/seika/data_structures/array_utils.c b/old_seika/data_structures/array_utils.c similarity index 100% rename from seika/data_structures/array_utils.c rename to old_seika/data_structures/array_utils.c diff --git a/seika/data_structures/array_utils.h b/old_seika/data_structures/array_utils.h similarity index 100% rename from seika/data_structures/array_utils.h rename to old_seika/data_structures/array_utils.h diff --git a/seika/data_structures/hash_map.c b/old_seika/data_structures/hash_map.c similarity index 100% rename from seika/data_structures/hash_map.c rename to old_seika/data_structures/hash_map.c diff --git a/seika/data_structures/hash_map.h b/old_seika/data_structures/hash_map.h similarity index 100% rename from seika/data_structures/hash_map.h rename to old_seika/data_structures/hash_map.h diff --git a/seika/data_structures/hash_map_string.c b/old_seika/data_structures/hash_map_string.c similarity index 100% rename from seika/data_structures/hash_map_string.c rename to old_seika/data_structures/hash_map_string.c diff --git a/seika/data_structures/hash_map_string.h b/old_seika/data_structures/hash_map_string.h similarity index 100% rename from seika/data_structures/hash_map_string.h rename to old_seika/data_structures/hash_map_string.h diff --git a/seika/data_structures/linked_list.c b/old_seika/data_structures/linked_list.c similarity index 100% rename from seika/data_structures/linked_list.c rename to old_seika/data_structures/linked_list.c diff --git a/seika/data_structures/linked_list.h b/old_seika/data_structures/linked_list.h similarity index 100% rename from seika/data_structures/linked_list.h rename to old_seika/data_structures/linked_list.h diff --git a/seika/data_structures/queue.c b/old_seika/data_structures/queue.c similarity index 100% rename from seika/data_structures/queue.c rename to old_seika/data_structures/queue.c diff --git a/seika/data_structures/queue.h b/old_seika/data_structures/queue.h similarity index 100% rename from seika/data_structures/queue.h rename to old_seika/data_structures/queue.h diff --git a/seika/data_structures/spatial_hash_map.c b/old_seika/data_structures/spatial_hash_map.c similarity index 100% rename from seika/data_structures/spatial_hash_map.c rename to old_seika/data_structures/spatial_hash_map.c diff --git a/seika/data_structures/spatial_hash_map.h b/old_seika/data_structures/spatial_hash_map.h similarity index 100% rename from seika/data_structures/spatial_hash_map.h rename to old_seika/data_structures/spatial_hash_map.h diff --git a/seika/data_structures/static_array.h b/old_seika/data_structures/static_array.h similarity index 100% rename from seika/data_structures/static_array.h rename to old_seika/data_structures/static_array.h diff --git a/seika/data_structures/tile_map.h b/old_seika/data_structures/tile_map.h similarity index 100% rename from seika/data_structures/tile_map.h rename to old_seika/data_structures/tile_map.h diff --git a/seika/defines.h b/old_seika/defines.h similarity index 100% rename from seika/defines.h rename to old_seika/defines.h diff --git a/seika/ecs/component.c b/old_seika/ecs/component.c similarity index 100% rename from seika/ecs/component.c rename to old_seika/ecs/component.c diff --git a/seika/ecs/component.h b/old_seika/ecs/component.h similarity index 100% rename from seika/ecs/component.h rename to old_seika/ecs/component.h diff --git a/seika/ecs/ec_system.c b/old_seika/ecs/ec_system.c similarity index 100% rename from seika/ecs/ec_system.c rename to old_seika/ecs/ec_system.c diff --git a/seika/ecs/ec_system.h b/old_seika/ecs/ec_system.h similarity index 100% rename from seika/ecs/ec_system.h rename to old_seika/ecs/ec_system.h diff --git a/seika/ecs/ecs.c b/old_seika/ecs/ecs.c similarity index 100% rename from seika/ecs/ecs.c rename to old_seika/ecs/ecs.c diff --git a/seika/ecs/ecs.h b/old_seika/ecs/ecs.h similarity index 100% rename from seika/ecs/ecs.h rename to old_seika/ecs/ecs.h diff --git a/seika/ecs/entity.c b/old_seika/ecs/entity.c similarity index 100% rename from seika/ecs/entity.c rename to old_seika/ecs/entity.c diff --git a/seika/ecs/entity.h b/old_seika/ecs/entity.h similarity index 100% rename from seika/ecs/entity.h rename to old_seika/ecs/entity.h diff --git a/seika/event.c b/old_seika/event.c similarity index 100% rename from seika/event.c rename to old_seika/event.c diff --git a/seika/event.h b/old_seika/event.h similarity index 100% rename from seika/event.h rename to old_seika/event.h diff --git a/seika/file_system.c b/old_seika/file_system.c similarity index 100% rename from seika/file_system.c rename to old_seika/file_system.c diff --git a/seika/file_system.h b/old_seika/file_system.h similarity index 100% rename from seika/file_system.h rename to old_seika/file_system.h diff --git a/seika/flag_utils.h b/old_seika/flag_utils.h similarity index 100% rename from seika/flag_utils.h rename to old_seika/flag_utils.h diff --git a/seika/input/input.c b/old_seika/input/input.c similarity index 100% rename from seika/input/input.c rename to old_seika/input/input.c diff --git a/seika/input/input.h b/old_seika/input/input.h similarity index 100% rename from seika/input/input.h rename to old_seika/input/input.h diff --git a/seika/input/sdl_gamepad_db.h b/old_seika/input/sdl_gamepad_db.h similarity index 100% rename from seika/input/sdl_gamepad_db.h rename to old_seika/input/sdl_gamepad_db.h diff --git a/seika/input/sdl_input.h b/old_seika/input/sdl_input.h similarity index 100% rename from seika/input/sdl_input.h rename to old_seika/input/sdl_input.h diff --git a/seika/logger.c b/old_seika/logger.c similarity index 100% rename from seika/logger.c rename to old_seika/logger.c diff --git a/seika/logger.h b/old_seika/logger.h similarity index 100% rename from seika/logger.h rename to old_seika/logger.h diff --git a/seika/macro_utils.h b/old_seika/macro_utils.h similarity index 100% rename from seika/macro_utils.h rename to old_seika/macro_utils.h diff --git a/seika/math/curve_float.c b/old_seika/math/curve_float.c similarity index 100% rename from seika/math/curve_float.c rename to old_seika/math/curve_float.c diff --git a/seika/math/curve_float.h b/old_seika/math/curve_float.h similarity index 100% rename from seika/math/curve_float.h rename to old_seika/math/curve_float.h diff --git a/seika/math/math.c b/old_seika/math/math.c similarity index 100% rename from seika/math/math.c rename to old_seika/math/math.c diff --git a/seika/math/math.h b/old_seika/math/math.h similarity index 100% rename from seika/math/math.h rename to old_seika/math/math.h diff --git a/seika/memory.c b/old_seika/memory.c similarity index 100% rename from seika/memory.c rename to old_seika/memory.c diff --git a/seika/memory.h b/old_seika/memory.h similarity index 100% rename from seika/memory.h rename to old_seika/memory.h diff --git a/seika/networking/network.c b/old_seika/networking/network.c similarity index 100% rename from seika/networking/network.c rename to old_seika/networking/network.c diff --git a/seika/networking/network.h b/old_seika/networking/network.h similarity index 100% rename from seika/networking/network.h rename to old_seika/networking/network.h diff --git a/seika/networking/network_socket.c b/old_seika/networking/network_socket.c similarity index 100% rename from seika/networking/network_socket.c rename to old_seika/networking/network_socket.c diff --git a/seika/networking/network_socket.h b/old_seika/networking/network_socket.h similarity index 100% rename from seika/networking/network_socket.h rename to old_seika/networking/network_socket.h diff --git a/seika/platform.c b/old_seika/platform.c similarity index 100% rename from seika/platform.c rename to old_seika/platform.c diff --git a/seika/platform.h b/old_seika/platform.h similarity index 100% rename from seika/platform.h rename to old_seika/platform.h diff --git a/seika/profile_code.h b/old_seika/profile_code.h similarity index 100% rename from seika/profile_code.h rename to old_seika/profile_code.h diff --git a/seika/rendering/font.c b/old_seika/rendering/font.c similarity index 100% rename from seika/rendering/font.c rename to old_seika/rendering/font.c diff --git a/seika/rendering/font.h b/old_seika/rendering/font.h similarity index 100% rename from seika/rendering/font.h rename to old_seika/rendering/font.h diff --git a/seika/rendering/frame_buffer.c b/old_seika/rendering/frame_buffer.c similarity index 100% rename from seika/rendering/frame_buffer.c rename to old_seika/rendering/frame_buffer.c diff --git a/seika/rendering/frame_buffer.h b/old_seika/rendering/frame_buffer.h similarity index 100% rename from seika/rendering/frame_buffer.h rename to old_seika/rendering/frame_buffer.h diff --git a/seika/rendering/render_context.c b/old_seika/rendering/render_context.c similarity index 100% rename from seika/rendering/render_context.c rename to old_seika/rendering/render_context.c diff --git a/seika/rendering/render_context.h b/old_seika/rendering/render_context.h similarity index 100% rename from seika/rendering/render_context.h rename to old_seika/rendering/render_context.h diff --git a/seika/rendering/renderer.c b/old_seika/rendering/renderer.c similarity index 100% rename from seika/rendering/renderer.c rename to old_seika/rendering/renderer.c diff --git a/seika/rendering/renderer.h b/old_seika/rendering/renderer.h similarity index 100% rename from seika/rendering/renderer.h rename to old_seika/rendering/renderer.h diff --git a/seika/rendering/shader/shader.c b/old_seika/rendering/shader/shader.c similarity index 100% rename from seika/rendering/shader/shader.c rename to old_seika/rendering/shader/shader.c diff --git a/seika/rendering/shader/shader.h b/old_seika/rendering/shader/shader.h similarity index 100% rename from seika/rendering/shader/shader.h rename to old_seika/rendering/shader/shader.h diff --git a/seika/rendering/shader/shader_cache.c b/old_seika/rendering/shader/shader_cache.c similarity index 100% rename from seika/rendering/shader/shader_cache.c rename to old_seika/rendering/shader/shader_cache.c diff --git a/seika/rendering/shader/shader_cache.h b/old_seika/rendering/shader/shader_cache.h similarity index 100% rename from seika/rendering/shader/shader_cache.h rename to old_seika/rendering/shader/shader_cache.h diff --git a/seika/rendering/shader/shader_file_parser.c b/old_seika/rendering/shader/shader_file_parser.c similarity index 100% rename from seika/rendering/shader/shader_file_parser.c rename to old_seika/rendering/shader/shader_file_parser.c diff --git a/seika/rendering/shader/shader_file_parser.h b/old_seika/rendering/shader/shader_file_parser.h similarity index 100% rename from seika/rendering/shader/shader_file_parser.h rename to old_seika/rendering/shader/shader_file_parser.h diff --git a/seika/rendering/shader/shader_instance.c b/old_seika/rendering/shader/shader_instance.c similarity index 100% rename from seika/rendering/shader/shader_instance.c rename to old_seika/rendering/shader/shader_instance.c diff --git a/seika/rendering/shader/shader_instance.h b/old_seika/rendering/shader/shader_instance.h similarity index 100% rename from seika/rendering/shader/shader_instance.h rename to old_seika/rendering/shader/shader_instance.h diff --git a/seika/rendering/shader/shader_instance_minimal.h b/old_seika/rendering/shader/shader_instance_minimal.h similarity index 100% rename from seika/rendering/shader/shader_instance_minimal.h rename to old_seika/rendering/shader/shader_instance_minimal.h diff --git a/seika/rendering/shader/shader_source.h b/old_seika/rendering/shader/shader_source.h similarity index 100% rename from seika/rendering/shader/shader_source.h rename to old_seika/rendering/shader/shader_source.h diff --git a/seika/rendering/texture.c b/old_seika/rendering/texture.c similarity index 100% rename from seika/rendering/texture.c rename to old_seika/rendering/texture.c diff --git a/seika/rendering/texture.h b/old_seika/rendering/texture.h similarity index 100% rename from seika/rendering/texture.h rename to old_seika/rendering/texture.h diff --git a/seika/seika.c b/old_seika/seika.c similarity index 100% rename from seika/seika.c rename to old_seika/seika.c diff --git a/seika/seika.h b/old_seika/seika.h similarity index 100% rename from seika/seika.h rename to old_seika/seika.h diff --git a/seika/string.c b/old_seika/string.c similarity index 100% rename from seika/string.c rename to old_seika/string.c diff --git a/seika/string.h b/old_seika/string.h similarity index 100% rename from seika/string.h rename to old_seika/string.h diff --git a/seika/thread/pthread.c b/old_seika/thread/pthread.c similarity index 100% rename from seika/thread/pthread.c rename to old_seika/thread/pthread.c diff --git a/seika/thread/pthread.h b/old_seika/thread/pthread.h similarity index 100% rename from seika/thread/pthread.h rename to old_seika/thread/pthread.h diff --git a/seika/thread/thread_pool.c b/old_seika/thread/thread_pool.c similarity index 100% rename from seika/thread/thread_pool.c rename to old_seika/thread/thread_pool.c diff --git a/seika/thread/thread_pool.h b/old_seika/thread/thread_pool.h similarity index 100% rename from seika/thread/thread_pool.h rename to old_seika/thread/thread_pool.h diff --git a/seika/version_info.h b/old_seika/version_info.h similarity index 100% rename from seika/version_info.h rename to old_seika/version_info.h diff --git a/seika1/logger.h b/seika1/logger.h index 437e33e..a13e28a 100644 --- a/seika1/logger.h +++ b/seika1/logger.h @@ -4,7 +4,7 @@ extern "C" { #endif -#include "seika/defines.h" +#include "seika1/defines.h" #ifndef SKA_LOG_BUFFER_SIZE #define SKA_LOG_BUFFER_SIZE 512 diff --git a/seika1/memory.h b/seika1/memory.h index 7c0773f..b6e91f8 100644 --- a/seika1/memory.h +++ b/seika1/memory.h @@ -4,7 +4,7 @@ extern "C" { #endif -#include "seika/defines.h" +#include "seika1/defines.h" #define SKA_ALLOC(DataType) \ (DataType*) ska_mem_allocate(sizeof(DataType)) diff --git a/seika1/version_info.h b/seika1/version_info.h index dd543ca..a8bd438 100644 --- a/seika1/version_info.h +++ b/seika1/version_info.h @@ -1,6 +1,6 @@ #pragma once -#include "seika/macro_utils.h" +#include "seika1/macro_utils.h" #define SKA_VERSION_MAJOR 0 #define SKA_VERSION_MINOR 1 From 2167d80e9b8c895e3b85b74923bf0e1800788720 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 17 Oct 2024 22:53:19 -0400 Subject: [PATCH 18/55] Renamed to new seika. --- CMakeLists.txt | 2 +- {seika1 => seika}/CMakeLists.txt | 0 {seika1 => seika}/assert.c | 4 ++-- {seika1 => seika}/assert.h | 4 ++-- {seika1 => seika}/data_structures/array2d.c | 4 ++-- {seika1 => seika}/data_structures/array2d.h | 2 +- {seika1 => seika}/data_structures/array_list.c | 4 ++-- {seika1 => seika}/data_structures/array_list.h | 2 +- {seika1 => seika}/data_structures/array_utils.c | 0 {seika1 => seika}/data_structures/array_utils.h | 2 +- {seika1 => seika}/data_structures/hash_map.c | 4 ++-- {seika1 => seika}/data_structures/hash_map.h | 2 +- {seika1 => seika}/data_structures/hash_map_string.c | 6 +++--- {seika1 => seika}/data_structures/hash_map_string.h | 2 +- {seika1 => seika}/data_structures/id_queue.c | 4 ++-- {seika1 => seika}/data_structures/id_queue.h | 2 +- {seika1 => seika}/data_structures/queue_template.h | 4 ++-- {seika1 => seika}/data_structures/spatial_hash_map.c | 4 ++-- {seika1 => seika}/data_structures/spatial_hash_map.h | 4 ++-- {seika1 => seika}/data_structures/static_array.h | 4 ++-- {seika1 => seika}/defines.h | 2 +- {seika1 => seika}/ecs/component.c | 10 +++++----- {seika1 => seika}/ecs/component.h | 2 +- {seika1 => seika}/ecs/ec_system.c | 10 +++++----- {seika1 => seika}/ecs/ec_system.h | 2 +- {seika1 => seika}/ecs/ecs.c | 0 {seika1 => seika}/ecs/ecs.h | 0 {seika1 => seika}/ecs/entity.c | 4 ++-- {seika1 => seika}/ecs/entity.h | 2 +- {seika1 => seika}/flag_utils.h | 0 {seika1 => seika}/logger.c | 2 +- {seika1 => seika}/logger.h | 2 +- {seika1 => seika}/macro_utils.h | 0 {seika1 => seika}/math/curve_float.c | 4 ++-- {seika1 => seika}/math/curve_float.h | 2 +- {seika1 => seika}/math/math.c | 0 {seika1 => seika}/math/math.h | 2 +- {seika1 => seika}/memory.c | 4 ++-- {seika1 => seika}/memory.h | 2 +- {seika1 => seika}/platform.c | 0 {seika1 => seika}/platform.h | 2 +- {seika1 => seika}/seika.c | 0 {seika1 => seika}/seika.h | 0 {seika1 => seika}/string.c | 4 ++-- {seika1 => seika}/string.h | 2 +- {seika1 => seika}/version_info.h | 2 +- test/test1.c | 12 ++++++------ 47 files changed, 66 insertions(+), 66 deletions(-) rename {seika1 => seika}/CMakeLists.txt (100%) rename {seika1 => seika}/assert.c (89%) rename {seika1 => seika}/assert.h (98%) rename {seika1 => seika}/data_structures/array2d.c (98%) rename {seika1 => seika}/data_structures/array2d.h (96%) rename {seika1 => seika}/data_structures/array_list.c (98%) rename {seika1 => seika}/data_structures/array_list.h (98%) rename {seika1 => seika}/data_structures/array_utils.c (100%) rename {seika1 => seika}/data_structures/array_utils.h (98%) rename {seika1 => seika}/data_structures/hash_map.c (99%) rename {seika1 => seika}/data_structures/hash_map.h (98%) rename {seika1 => seika}/data_structures/hash_map_string.c (99%) rename {seika1 => seika}/data_structures/hash_map_string.h (98%) rename {seika1 => seika}/data_structures/id_queue.c (97%) rename {seika1 => seika}/data_structures/id_queue.h (95%) rename {seika1 => seika}/data_structures/queue_template.h (97%) rename {seika1 => seika}/data_structures/spatial_hash_map.c (99%) rename {seika1 => seika}/data_structures/spatial_hash_map.h (96%) rename {seika1 => seika}/data_structures/static_array.h (98%) rename {seika1 => seika}/defines.h (95%) rename {seika1 => seika}/ecs/component.c (97%) rename {seika1 => seika}/ecs/component.h (98%) rename {seika1 => seika}/ecs/ec_system.c (99%) rename {seika1 => seika}/ecs/ec_system.h (99%) rename {seika1 => seika}/ecs/ecs.c (100%) rename {seika1 => seika}/ecs/ecs.h (100%) rename {seika1 => seika}/ecs/entity.c (92%) rename {seika1 => seika}/ecs/entity.h (93%) rename {seika1 => seika}/flag_utils.h (100%) rename {seika1 => seika}/logger.c (99%) rename {seika1 => seika}/logger.h (96%) rename {seika1 => seika}/macro_utils.h (100%) rename {seika1 => seika}/math/curve_float.c (98%) rename {seika1 => seika}/math/curve_float.h (96%) rename {seika1 => seika}/math/math.c (100%) rename {seika1 => seika}/math/math.h (99%) rename {seika1 => seika}/memory.c (98%) rename {seika1 => seika}/memory.h (97%) rename {seika1 => seika}/platform.c (100%) rename {seika1 => seika}/platform.h (94%) rename {seika1 => seika}/seika.c (100%) rename {seika1 => seika}/seika.h (100%) rename {seika1 => seika}/string.c (98%) rename {seika1 => seika}/string.h (97%) rename {seika1 => seika}/version_info.h (88%) diff --git a/CMakeLists.txt b/CMakeLists.txt index a856e85..c0ea238 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -37,7 +37,7 @@ if (SEIKA_ENABLE_OLD) add_subdirectory(old_seika) endif() if (SEIKA_ENABLE_1) - add_subdirectory(seika1) + add_subdirectory(seika) endif() if ("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}") diff --git a/seika1/CMakeLists.txt b/seika/CMakeLists.txt similarity index 100% rename from seika1/CMakeLists.txt rename to seika/CMakeLists.txt diff --git a/seika1/assert.c b/seika/assert.c similarity index 89% rename from seika1/assert.c rename to seika/assert.c index 6f61759..5ecb4ce 100644 --- a/seika1/assert.c +++ b/seika/assert.c @@ -1,10 +1,10 @@ -#include "seika1/assert.h" +#include "seika/assert.h" #include #include #include -#include "seika1/string.h" +#include "seika/string.h" void ska_print_assert_err(const char* fmt, ...) { #define SKA_PRINT_BUFFER_SIZE 496 diff --git a/seika1/assert.h b/seika/assert.h similarity index 98% rename from seika1/assert.h rename to seika/assert.h index 0ad4b0c..5042e80 100644 --- a/seika1/assert.h +++ b/seika/assert.h @@ -9,8 +9,8 @@ extern "C" { #include #include -#include "seika1/defines.h" -#include "seika1/platform.h" +#include "seika/defines.h" +#include "seika/platform.h" #define SKA_ASSERT_FAIL_EXIT_CODE (-1) diff --git a/seika1/data_structures/array2d.c b/seika/data_structures/array2d.c similarity index 98% rename from seika1/data_structures/array2d.c rename to seika/data_structures/array2d.c index 42c3b6c..a2d6dec 100644 --- a/seika1/data_structures/array2d.c +++ b/seika/data_structures/array2d.c @@ -2,8 +2,8 @@ #include -#include "seika1/memory.h" -#include "seika1/assert.h" +#include "seika/memory.h" +#include "seika/assert.h" #define SKA_ARRAY2D_IS_COORD_INVALID(ARRAY2D, ROW, COL) ((int32)ROW >= ARRAY2D->size.w || (int32)COL >= ARRAY2D->size.h) diff --git a/seika1/data_structures/array2d.h b/seika/data_structures/array2d.h similarity index 96% rename from seika1/data_structures/array2d.h rename to seika/data_structures/array2d.h index b5c4d2d..f2c9cc0 100644 --- a/seika1/data_structures/array2d.h +++ b/seika/data_structures/array2d.h @@ -1,6 +1,6 @@ #pragma once -#include "seika1/math/math.h" +#include "seika/math/math.h" typedef struct SkaArray2D { void** data; diff --git a/seika1/data_structures/array_list.c b/seika/data_structures/array_list.c similarity index 98% rename from seika1/data_structures/array_list.c rename to seika/data_structures/array_list.c index 318c701..37cb680 100644 --- a/seika1/data_structures/array_list.c +++ b/seika/data_structures/array_list.c @@ -2,8 +2,8 @@ #include -#include "seika1/memory.h" -#include "seika1/assert.h" +#include "seika/memory.h" +#include "seika/assert.h" #define SKA_ARRAY_LIST_DEFAULT_CAPACITY 16 diff --git a/seika1/data_structures/array_list.h b/seika/data_structures/array_list.h similarity index 98% rename from seika1/data_structures/array_list.h rename to seika/data_structures/array_list.h index 1e6bc00..790521c 100644 --- a/seika1/data_structures/array_list.h +++ b/seika/data_structures/array_list.h @@ -1,6 +1,6 @@ #pragma once -#include "seika1/defines.h" +#include "seika/defines.h" #define SKA_ARRAY_LIST_GET_ARRAY(LIST, TYPE) ((TYPE*)((LIST)->data)) #define SKA_ARRAY_LIST_FOR_EACH(LIST, TYPE, VALUE) for(TYPE* VALUE = SKA_ARRAY_LIST_GET_ARRAY(LIST, TYPE), *VALUE##_end = VALUE + (LIST)->size; VALUE < VALUE##_end; VALUE++) diff --git a/seika1/data_structures/array_utils.c b/seika/data_structures/array_utils.c similarity index 100% rename from seika1/data_structures/array_utils.c rename to seika/data_structures/array_utils.c diff --git a/seika1/data_structures/array_utils.h b/seika/data_structures/array_utils.h similarity index 98% rename from seika1/data_structures/array_utils.h rename to seika/data_structures/array_utils.h index e0d3846..14cb3c3 100644 --- a/seika1/data_structures/array_utils.h +++ b/seika/data_structures/array_utils.h @@ -1,6 +1,6 @@ #pragma once -#include "seika1/defines.h" +#include "seika/defines.h" #define SKA_ARRAY_UTILS_REMOVE_ARRAY_ITEM(ARRAY, ARRAY_SIZE, ELEMENT, EMPTY_VALUE) \ { \ diff --git a/seika1/data_structures/hash_map.c b/seika/data_structures/hash_map.c similarity index 99% rename from seika1/data_structures/hash_map.c rename to seika/data_structures/hash_map.c index 204ad4b..f6d94c1 100644 --- a/seika1/data_structures/hash_map.c +++ b/seika/data_structures/hash_map.c @@ -2,8 +2,8 @@ #include -#include "seika1/memory.h" -#include "seika1/assert.h" +#include "seika/memory.h" +#include "seika/assert.h" static usize se_default_hash(void* raw_key, usize key_size); static int32 se_default_compare(void* first_key, void* second_key, usize key_size); diff --git a/seika1/data_structures/hash_map.h b/seika/data_structures/hash_map.h similarity index 98% rename from seika1/data_structures/hash_map.h rename to seika/data_structures/hash_map.h index ff29c87..5a50512 100644 --- a/seika1/data_structures/hash_map.h +++ b/seika/data_structures/hash_map.h @@ -4,7 +4,7 @@ extern "C" { #endif -#include "seika1/defines.h" +#include "seika/defines.h" #define SKA_HASH_MAP_SHRINK_THRESHOLD 0.25f #define SKA_HASH_MAP_MIN_CAPACITY 8 diff --git a/seika1/data_structures/hash_map_string.c b/seika/data_structures/hash_map_string.c similarity index 99% rename from seika1/data_structures/hash_map_string.c rename to seika/data_structures/hash_map_string.c index b998cc3..cec1a47 100644 --- a/seika1/data_structures/hash_map_string.c +++ b/seika/data_structures/hash_map_string.c @@ -2,9 +2,9 @@ #include -#include "seika1/string.h" -#include "seika1/memory.h" -#include "seika1/assert.h" +#include "seika/string.h" +#include "seika/memory.h" +#include "seika/assert.h" static usize ska_default_hash_string(const char* raw_key); static int32 ska_default_compare_string(const char* first_key, const char* second_key); diff --git a/seika1/data_structures/hash_map_string.h b/seika/data_structures/hash_map_string.h similarity index 98% rename from seika1/data_structures/hash_map_string.h rename to seika/data_structures/hash_map_string.h index 2d484a6..658c336 100644 --- a/seika1/data_structures/hash_map_string.h +++ b/seika/data_structures/hash_map_string.h @@ -4,7 +4,7 @@ extern "C" { #endif -#include "seika1/defines.h" +#include "seika/defines.h" #define SKA_STRING_HASH_MAP_SHRINK_THRESHOLD 0.25f #define SKA_STRING_HASH_MAP_MIN_CAPACITY 8 diff --git a/seika1/data_structures/id_queue.c b/seika/data_structures/id_queue.c similarity index 97% rename from seika1/data_structures/id_queue.c rename to seika/data_structures/id_queue.c index 6845c3b..2184a6d 100644 --- a/seika1/data_structures/id_queue.c +++ b/seika/data_structures/id_queue.c @@ -1,7 +1,7 @@ #include "id_queue.h" -#include "seika1/assert.h" -#include "seika1/memory.h" +#include "seika/assert.h" +#include "seika/memory.h" SkaIdQueue* ska_id_queue_create(usize initialCapacity) { SkaIdQueue* queue = SKA_ALLOC(SkaIdQueue); diff --git a/seika1/data_structures/id_queue.h b/seika/data_structures/id_queue.h similarity index 95% rename from seika1/data_structures/id_queue.h rename to seika/data_structures/id_queue.h index 379428f..2eeaae4 100644 --- a/seika1/data_structures/id_queue.h +++ b/seika/data_structures/id_queue.h @@ -2,7 +2,7 @@ #define SKA_QUEUE_T uint32 -#include "seika1/defines.h" +#include "seika/defines.h" // Unsigned int queue typedef struct SkaIdQueue { diff --git a/seika1/data_structures/queue_template.h b/seika/data_structures/queue_template.h similarity index 97% rename from seika1/data_structures/queue_template.h rename to seika/data_structures/queue_template.h index 9346381..bc36d63 100644 --- a/seika1/data_structures/queue_template.h +++ b/seika/data_structures/queue_template.h @@ -4,8 +4,8 @@ #error "SKA_QUEUE_TEMPLATE must be defined before including queue_template.h" #endif -#include "seika1/defines.h" -#include "seika1/memory.h" +#include "seika/defines.h" +#include "seika/memory.h" #define SKA_QUEUE_T(Name) SkaQueue_##Name #define SKA_QUEUE_FUNC(Name, Suffix) ska_queue_##Name##_##Suffix diff --git a/seika1/data_structures/spatial_hash_map.c b/seika/data_structures/spatial_hash_map.c similarity index 99% rename from seika1/data_structures/spatial_hash_map.c rename to seika/data_structures/spatial_hash_map.c index 597302c..a946f07 100644 --- a/seika1/data_structures/spatial_hash_map.c +++ b/seika/data_structures/spatial_hash_map.c @@ -3,8 +3,8 @@ #include #include -#include "seika1/memory.h" -#include "seika1/assert.h" +#include "seika/memory.h" +#include "seika/assert.h" #define SKA_SPATIAL_HASH_NULL_ENTITY 4294967295 #define SKA_SPATIAL_HASH_MAX_POSITION_HASH 8 diff --git a/seika1/data_structures/spatial_hash_map.h b/seika/data_structures/spatial_hash_map.h similarity index 96% rename from seika1/data_structures/spatial_hash_map.h rename to seika/data_structures/spatial_hash_map.h index a5a6242..37acb34 100644 --- a/seika1/data_structures/spatial_hash_map.h +++ b/seika/data_structures/spatial_hash_map.h @@ -1,7 +1,7 @@ #pragma once -#include "seika1/math/math.h" -#include "seika1/data_structures/hash_map.h" +#include "seika/math/math.h" +#include "seika/data_structures/hash_map.h" #define SKA_SPATIAL_HASH_GRID_SPACE_ENTITY_LIMIT 32 #define SKA_SPATIAL_HASH_GRID_MAX_COLLISIONS 16 diff --git a/seika1/data_structures/static_array.h b/seika/data_structures/static_array.h similarity index 98% rename from seika1/data_structures/static_array.h rename to seika/data_structures/static_array.h index b0ded8d..05caa9a 100644 --- a/seika1/data_structures/static_array.h +++ b/seika/data_structures/static_array.h @@ -1,7 +1,7 @@ #pragma once -#include "seika1/defines.h" -#include "seika1/data_structures/array_utils.h" +#include "seika/defines.h" +#include "seika/data_structures/array_utils.h" // Helper class for generalized use of static arrays diff --git a/seika1/defines.h b/seika/defines.h similarity index 95% rename from seika1/defines.h rename to seika/defines.h index f0e4718..705fda8 100644 --- a/seika1/defines.h +++ b/seika/defines.h @@ -8,7 +8,7 @@ extern "C" { #include #include -#include "seika1/version_info.h" +#include "seika/version_info.h" typedef size_t usize; diff --git a/seika1/ecs/component.c b/seika/ecs/component.c similarity index 97% rename from seika1/ecs/component.c rename to seika/ecs/component.c index 862c789..d0b500d 100644 --- a/seika1/ecs/component.c +++ b/seika/ecs/component.c @@ -2,11 +2,11 @@ #include "component.h" -#include "seika1/string.h" -#include "seika1/memory.h" -#include "seika1/assert.h" -#include "seika1/data_structures/hash_map_string.h" -#include "seika1/data_structures/array_list.h" +#include "seika/string.h" +#include "seika/memory.h" +#include "seika/assert.h" +#include "seika/data_structures/hash_map_string.h" +#include "seika/data_structures/array_list.h" //--- Component ---// static SkaComponentIndex globalComponentIndex = 0; diff --git a/seika1/ecs/component.h b/seika/ecs/component.h similarity index 98% rename from seika1/ecs/component.h rename to seika/ecs/component.h index d2562a1..bd67f81 100644 --- a/seika1/ecs/component.h +++ b/seika/ecs/component.h @@ -6,7 +6,7 @@ extern "C" { #endif -#include "seika1/defines.h" +#include "seika/defines.h" #include "entity.h" diff --git a/seika1/ecs/ec_system.c b/seika/ecs/ec_system.c similarity index 99% rename from seika1/ecs/ec_system.c rename to seika/ecs/ec_system.c index 986f469..883c158 100644 --- a/seika1/ecs/ec_system.c +++ b/seika/ecs/ec_system.c @@ -2,11 +2,11 @@ #include "ec_system.h" -#include "seika1/string.h" -#include "seika1/flag_utils.h" -#include "seika1/logger.h" -#include "seika1/memory.h" -#include "seika1/assert.h" +#include "seika/string.h" +#include "seika/flag_utils.h" +#include "seika/logger.h" +#include "seika/memory.h" +#include "seika/assert.h" //--- EC System Manager ---// #define MAX_ENTITY_SYSTEMS_PER_HOOK 12 diff --git a/seika1/ecs/ec_system.h b/seika/ecs/ec_system.h similarity index 99% rename from seika1/ecs/ec_system.h rename to seika/ecs/ec_system.h index 2d0f304..59735d8 100644 --- a/seika1/ecs/ec_system.h +++ b/seika/ecs/ec_system.h @@ -3,7 +3,7 @@ #if SKA_ECS #include "component.h" -#include "seika1/data_structures/array_list.h" +#include "seika/data_structures/array_list.h" #define SKA_ECS_SYSTEM_CREATE(NAME, ...) \ ska_ecs_system_create_with_signature_string(NAME, #__VA_ARGS__) diff --git a/seika1/ecs/ecs.c b/seika/ecs/ecs.c similarity index 100% rename from seika1/ecs/ecs.c rename to seika/ecs/ecs.c diff --git a/seika1/ecs/ecs.h b/seika/ecs/ecs.h similarity index 100% rename from seika1/ecs/ecs.h rename to seika/ecs/ecs.h diff --git a/seika1/ecs/entity.c b/seika/ecs/entity.c similarity index 92% rename from seika1/ecs/entity.c rename to seika/ecs/entity.c index 3d63ddc..c857597 100644 --- a/seika1/ecs/entity.c +++ b/seika/ecs/entity.c @@ -1,8 +1,8 @@ #if SKA_ECS #include "entity.h" -#include "seika1/data_structures/id_queue.h" -#include "seika1/assert.h" +#include "seika/data_structures/id_queue.h" +#include "seika/assert.h" #define SKA_INITIAL_ENTITY_CAPACITY 1000 diff --git a/seika1/ecs/entity.h b/seika/ecs/entity.h similarity index 93% rename from seika1/ecs/entity.h rename to seika/ecs/entity.h index dcd8d89..a094485 100644 --- a/seika1/ecs/entity.h +++ b/seika/ecs/entity.h @@ -2,7 +2,7 @@ #if SKA_ECS -#include "seika1/defines.h" +#include "seika/defines.h" // Entity is defined as a unsigned 32-bit integer typedef uint32 SkaEntity; diff --git a/seika1/flag_utils.h b/seika/flag_utils.h similarity index 100% rename from seika1/flag_utils.h rename to seika/flag_utils.h diff --git a/seika1/logger.c b/seika/logger.c similarity index 99% rename from seika1/logger.c rename to seika/logger.c index 9e92f2f..5779866 100644 --- a/seika1/logger.c +++ b/seika/logger.c @@ -4,7 +4,7 @@ #include #include -#include "seika1/string.h" +#include "seika/string.h" #include "memory.h" #define SKA_LOGGER_MAX_QUEUED_MESSAGES 16 diff --git a/seika1/logger.h b/seika/logger.h similarity index 96% rename from seika1/logger.h rename to seika/logger.h index a13e28a..437e33e 100644 --- a/seika1/logger.h +++ b/seika/logger.h @@ -4,7 +4,7 @@ extern "C" { #endif -#include "seika1/defines.h" +#include "seika/defines.h" #ifndef SKA_LOG_BUFFER_SIZE #define SKA_LOG_BUFFER_SIZE 512 diff --git a/seika1/macro_utils.h b/seika/macro_utils.h similarity index 100% rename from seika1/macro_utils.h rename to seika/macro_utils.h diff --git a/seika1/math/curve_float.c b/seika/math/curve_float.c similarity index 98% rename from seika1/math/curve_float.c rename to seika/math/curve_float.c index 07c9131..d5197fb 100644 --- a/seika1/math/curve_float.c +++ b/seika/math/curve_float.c @@ -1,7 +1,7 @@ #include "curve_float.h" -#include "seika1/math/math.h" -#include "seika1/assert.h" +#include "seika/math/math.h" +#include "seika/assert.h" // Helper functions void control_point_swap(SkaCurveControlPoint* pointA, SkaCurveControlPoint* pointB) { diff --git a/seika1/math/curve_float.h b/seika/math/curve_float.h similarity index 96% rename from seika1/math/curve_float.h rename to seika/math/curve_float.h index 344d2bf..9c5c88a 100644 --- a/seika1/math/curve_float.h +++ b/seika/math/curve_float.h @@ -4,7 +4,7 @@ extern "C" { #endif -#include "seika1/defines.h" +#include "seika/defines.h" #define SKA_CURVE_MAX_CONTROL_POINTS 16 diff --git a/seika1/math/math.c b/seika/math/math.c similarity index 100% rename from seika1/math/math.c rename to seika/math/math.c diff --git a/seika1/math/math.h b/seika/math/math.h similarity index 99% rename from seika1/math/math.h rename to seika/math/math.h index b28d498..837cd2e 100644 --- a/seika1/math/math.h +++ b/seika/math/math.h @@ -10,7 +10,7 @@ extern "C" { #include -#include "seika1/defines.h" +#include "seika/defines.h" #define SKA_PI 3.14159265358979323846f #define SKA_RAD_2_DEG(RADIANS) ((RADIANS) * (180.0 / (f64)SKA_PI)) diff --git a/seika1/memory.c b/seika/memory.c similarity index 98% rename from seika1/memory.c rename to seika/memory.c index d7c9da6..05d539c 100644 --- a/seika1/memory.c +++ b/seika/memory.c @@ -1,5 +1,5 @@ -#include "seika1/memory.h" -#include "seika1/assert.h" +#include "seika/memory.h" +#include "seika/assert.h" // Internal default allocator implementation diff --git a/seika1/memory.h b/seika/memory.h similarity index 97% rename from seika1/memory.h rename to seika/memory.h index b6e91f8..7c0773f 100644 --- a/seika1/memory.h +++ b/seika/memory.h @@ -4,7 +4,7 @@ extern "C" { #endif -#include "seika1/defines.h" +#include "seika/defines.h" #define SKA_ALLOC(DataType) \ (DataType*) ska_mem_allocate(sizeof(DataType)) diff --git a/seika1/platform.c b/seika/platform.c similarity index 100% rename from seika1/platform.c rename to seika/platform.c diff --git a/seika1/platform.h b/seika/platform.h similarity index 94% rename from seika1/platform.h rename to seika/platform.h index d3136dd..a63be05 100644 --- a/seika1/platform.h +++ b/seika/platform.h @@ -4,7 +4,7 @@ extern "C" { #endif -#include "seika1/defines.h" +#include "seika/defines.h" #if defined(_WIN32) || defined(_WIN64) // Windows #define SKA_TRIGGER_BREAKPOINT __debugbreak() diff --git a/seika1/seika.c b/seika/seika.c similarity index 100% rename from seika1/seika.c rename to seika/seika.c diff --git a/seika1/seika.h b/seika/seika.h similarity index 100% rename from seika1/seika.h rename to seika/seika.h diff --git a/seika1/string.c b/seika/string.c similarity index 98% rename from seika1/string.c rename to seika/string.c index a6260b6..562f5fe 100644 --- a/seika1/string.c +++ b/seika/string.c @@ -1,9 +1,9 @@ -#include "seika1/string.h" +#include "seika/string.h" #include #include -#include "seika1/memory.h" +#include "seika/memory.h" #ifdef _MSC_VER #pragma warning(disable : 4996) // for strcpy and strncat diff --git a/seika1/string.h b/seika/string.h similarity index 97% rename from seika1/string.h rename to seika/string.h index 3b5a572..b872934 100644 --- a/seika1/string.h +++ b/seika/string.h @@ -1,6 +1,6 @@ #pragma once -#include "seika1/defines.h" +#include "seika/defines.h" // Copies string and allocated new memory char* ska_strdup(const char* string); diff --git a/seika1/version_info.h b/seika/version_info.h similarity index 88% rename from seika1/version_info.h rename to seika/version_info.h index a8bd438..dd543ca 100644 --- a/seika1/version_info.h +++ b/seika/version_info.h @@ -1,6 +1,6 @@ #pragma once -#include "seika1/macro_utils.h" +#include "seika/macro_utils.h" #define SKA_VERSION_MAJOR 0 #define SKA_VERSION_MINOR 1 diff --git a/test/test1.c b/test/test1.c index 608aac9..09df0e3 100644 --- a/test/test1.c +++ b/test/test1.c @@ -1,14 +1,14 @@ #include #include -#include "seika1/memory.h" -#include "seika1/data_structures/array_list.h" -#include "seika1/data_structures/id_queue.h" -#include "seika1/math/math.h" +#include "seika/memory.h" +#include "seika/data_structures/array_list.h" +#include "seika/data_structures/id_queue.h" +#include "seika/math/math.h" #if SKA_ECS -#include "seika1/ecs/ecs.h" -#include "seika1/ecs/ec_system.h" +#include "seika/ecs/ecs.h" +#include "seika/ecs/ec_system.h" #endif #define RESOURCES_PATH "test/resources" From 0b4f8dc352a46f1691d33669a0444b773f249779 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 17 Oct 2024 22:58:14 -0400 Subject: [PATCH 19/55] Updates. --- CMakeLists.txt | 24 ++++++++++++------------ seika/ecs/entity.h | 2 +- 2 files changed, 13 insertions(+), 13 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index c0ea238..72216f2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -10,21 +10,21 @@ option(SEIKA_ENABLE_OLD "Will build old seika lib" OFF) option(SEIKA_ENABLE_1 "Will build new seika lib" ON) # Compilation Modes -option(SEIKA_ENABLE_ECS "Will enable ecs" ON) -option(SEIKA_ENABLE_INPUT "Will enable input" OFF) -option(SEIKA_ENABLE_RENDERING "Will enable rendering" OFF) -option(SEIKA_ENABLE_AUDIO "Will enable audio" OFF) +option(SEIKA_ECS "Will enable ecs" ON) +option(SEIKA_INPUT "Will enable input" OFF) +option(SEIKA_RENDERING "Will enable rendering" OFF) +option(SEIKA_AUDIO "Will enable audio" OFF) -add_compile_definitions(SKA_ECS=$,1,0>) -add_compile_definitions(SKA_INPUT=$,1,0>) -add_compile_definitions(SKA_RENDERING=$,1,0>) -add_compile_definitions(SKA_AUDIO=$,1,0>) +add_compile_definitions(SKA_ECS=$,1,0>) +add_compile_definitions(SKA_INPUT=$,1,0>) +add_compile_definitions(SKA_RENDERING=$,1,0>) +add_compile_definitions(SKA_AUDIO=$,1,0>) function(set_common_compile_definitions target) - target_compile_definitions(${target} PRIVATE SKA_ECS=$,1,0>) - target_compile_definitions(${target} PRIVATE SKA_INPUT=$,1,0>) - target_compile_definitions(${target} PRIVATE SKA_RENDERING=$,1,0>) - target_compile_definitions(${target} PRIVATE SKA_AUDIO=$,1,0>) + target_compile_definitions(${target} PRIVATE SKA_ECS=$,1,0>) + target_compile_definitions(${target} PRIVATE SKA_INPUT=$,1,0>) + target_compile_definitions(${target} PRIVATE SKA_RENDERING=$,1,0>) + target_compile_definitions(${target} PRIVATE SKA_AUDIO=$,1,0>) endfunction() set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) diff --git a/seika/ecs/entity.h b/seika/ecs/entity.h index a094485..d372300 100644 --- a/seika/ecs/entity.h +++ b/seika/ecs/entity.h @@ -6,7 +6,7 @@ // Entity is defined as a unsigned 32-bit integer typedef uint32 SkaEntity; -#define SKA_NULL_ENTITY (SkaEntity)0 +#define SKA_NULL_ENTITY (SkaEntity)-1 void ska_ecs_entity_initialize(); void ska_ecs_entity_finalize(); From 1a1d42810565222bb90482704175f3f6dcc1e584 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 17 Oct 2024 23:08:19 -0400 Subject: [PATCH 20/55] Added input. --- CMakeLists.txt | 2 +- seika/input/input.c | 572 + seika/input/input.h | 296 + seika/input/sdl_gamepad_db.h | 41991 +++++++++++++++++++++++++++++++++ seika/input/sdl_input.h | 337 + test/test1.c | 100 + 6 files changed, 43297 insertions(+), 1 deletion(-) create mode 100644 seika/input/input.c create mode 100644 seika/input/input.h create mode 100644 seika/input/sdl_gamepad_db.h create mode 100644 seika/input/sdl_input.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 72216f2..0ad0eb8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -11,7 +11,7 @@ option(SEIKA_ENABLE_1 "Will build new seika lib" ON) # Compilation Modes option(SEIKA_ECS "Will enable ecs" ON) -option(SEIKA_INPUT "Will enable input" OFF) +option(SEIKA_INPUT "Will enable input" ON) option(SEIKA_RENDERING "Will enable rendering" OFF) option(SEIKA_AUDIO "Will enable audio" OFF) diff --git a/seika/input/input.c b/seika/input/input.c new file mode 100644 index 0000000..42d86aa --- /dev/null +++ b/seika/input/input.c @@ -0,0 +1,572 @@ +#if SKA_INPUT + +#include "input.h" +#include "seika/string.h" +#include "seika/assert.h" +#include "seika/memory.h" + +#define SKA_INPUT_MAX_KEY_STATE_CLEANUP_SIZE 16 + +typedef struct SkaAxisInputValues { + SkaVector2 left; + SkaVector2 right; +} SkaAxisInputValues; + +typedef struct SkaInputKeyState { + bool isPressed; + bool isJustPressed; + bool isJustReleased; + f32 strength; + SkaAxisInputValues prevAxisValues[SKA_INPUT_MAX_DEVICES]; +} SkaInputKeyState; + +typedef struct SkaInputStateCleanup { + SkaInputKey key; + SkaInputDeviceIndex deviceIndex; +} SkaInputStateCleanup; + +typedef struct SkaInputActionData { + SkaInputAction action; + SkaInputActionHandle handle; +} SkaInputActionData; + +typedef struct SkaInputState { + SkaInputKeyState inputKeyState[SKA_INPUT_MAX_DEVICES][SkaInputKey_NUMBER_OF_KEYS]; + + SkaAxisInputValues prevAxisInputs[SKA_INPUT_MAX_DEVICES]; + + SkaInputStateCleanup cleanupKeyStateJustPressed[SKA_INPUT_MAX_KEY_STATE_CLEANUP_SIZE]; + SkaInputStateCleanup cleanupKeyStateJustReleased[SKA_INPUT_MAX_KEY_STATE_CLEANUP_SIZE]; + usize cleanupKeyStateJustPressedCount; + usize cleanupKeyStateJustReleasedCount; + + SkaInputActionHandle inputActionHandleIndex; + SkaInputActionData inputActionData[SKA_INPUT_MAX_DEVICES][SKA_INPUT_MAX_INPUT_ACTIONS]; +} SkaInputState; + +#define DEFAULT_INPUT_STATE {0} + +static SkaInputState inputState = DEFAULT_INPUT_STATE; +static SkaMouse globalMouse = {0}; + +static SkaInputKey get_key_from_2d_axis_key(SkaInputKey axis2DKey, SkaAxisInputValues* axisInputValues, f32 axisValue); +static void set_prev_input_axis_value(SkaInputKey key, SkaAxisInputValues* axisInputValues, f32 axisValue); +static void update_axis_key_state(SkaInputKey key, SkaInputInteractionStatus interactionStatus, f32 axisValue, SkaInputDeviceIndex deviceIndex); + +const char* ska_input_key_to_string(SkaInputKey key) { + static const char* keyNames[SkaInputKey_NUMBER_OF_KEYS] = { + [SkaInputKey_INVALID] = "Invalid", + // Gamepad + [SkaInputKey_GAMEPAD_DPAD_DOWN] = "Gamepad Dpad Down", + [SkaInputKey_GAMEPAD_DPAD_UP] = "Gamepad Dpad Up", + [SkaInputKey_GAMEPAD_DPAD_LEFT] = "Gamepad Dpad Left", + [SkaInputKey_GAMEPAD_DPAD_RIGHT] = "Gamepad Dpad Right", + [SkaInputKey_GAMEPAD_FACE_BUTTON_NORTH] = "Gamepad Face Button North", + [SkaInputKey_GAMEPAD_FACE_BUTTON_SOUTH] = "Gamepad Face Button South", + [SkaInputKey_GAMEPAD_FACE_BUTTON_EAST] = "Gamepad Face Button East", + [SkaInputKey_GAMEPAD_FACE_BUTTON_WEST] = "Gamepad Face Button West", + [SkaInputKey_GAMEPAD_START] = "Gamepad Start", + [SkaInputKey_GAMEPAD_BACK] = "Gamepad Back", + [SkaInputKey_GAMEPAD_LEFT_SHOULDER] = "Gamepad Left Shoulder", + [SkaInputKey_GAMEPAD_LEFT_TRIGGER] = "Gamepad Left Trigger", + [SkaInputKey_GAMEPAD_LEFT_ANALOG_BUTTON] = "Gamepad Left Analog Button", + [SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X] = "Gamepad Left Analog 2D Axis X", + [SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y] = "Gamepad Left Analog 2D Axis Y", + [SkaInputKey_GAMEPAD_RIGHT_SHOULDER] = "Gamepad Right Shoulder", + [SkaInputKey_GAMEPAD_RIGHT_TRIGGER] = "Gamepad Right Trigger", + [SkaInputKey_GAMEPAD_RIGHT_ANALOG_BUTTON] = "Gamepad Right Analog Button", + [SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X] = "Gamepad Right Analog 2D Axis X", + [SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_Y] = "Gamepad Right Analog 2D Axis Y", + [SkaInputKey_GAMEPAD_LEFT_ANALOG_LEFT] = "Gamepad Left Analog Left", + [SkaInputKey_GAMEPAD_LEFT_ANALOG_RIGHT] = "Gamepad Left Analog Right", + [SkaInputKey_GAMEPAD_LEFT_ANALOG_UP] = "Gamepad Left Analog Up", + [SkaInputKey_GAMEPAD_LEFT_ANALOG_DOWN] = "Gamepad Left Analog Down", + [SkaInputKey_GAMEPAD_RIGHT_ANALOG_LEFT] = "Gamepad Right Analog Left", + [SkaInputKey_GAMEPAD_RIGHT_ANALOG_RIGHT] = "Gamepad Right Analog Right", + [SkaInputKey_GAMEPAD_RIGHT_ANALOG_UP] = "Gamepad Right Analog Up", + [SkaInputKey_GAMEPAD_RIGHT_ANALOG_DOWN] = "Gamepad Right Analog Down", + // Keyboard + [SkaInputKey_KEYBOARD_TAB] = "Tab", + [SkaInputKey_KEYBOARD_LEFT] = "Left", + [SkaInputKey_KEYBOARD_RIGHT] = "Right", + [SkaInputKey_KEYBOARD_UP] = "Up", + [SkaInputKey_KEYBOARD_DOWN] = "Down", + [SkaInputKey_KEYBOARD_PAGE_DOWN] = "Page Down", + [SkaInputKey_KEYBOARD_PAGE_UP] = "Page Up", + [SkaInputKey_KEYBOARD_HOME] = "Home", + [SkaInputKey_KEYBOARD_END] = "End", + [SkaInputKey_KEYBOARD_INSERT] = "Insert", + [SkaInputKey_KEYBOARD_DELETE] = "Delete", + [SkaInputKey_KEYBOARD_BACKSPACE] = "Backspace", + [SkaInputKey_KEYBOARD_SPACE] = "Space", + [SkaInputKey_KEYBOARD_RETURN] = "Return", + [SkaInputKey_KEYBOARD_ESCAPE] = "Escape", + [SkaInputKey_KEYBOARD_QUOTE] = "Quote", + [SkaInputKey_KEYBOARD_COMMA] = "Comma", + [SkaInputKey_KEYBOARD_MINUS] = "Minus", + [SkaInputKey_KEYBOARD_PERIOD] = "Period", + [SkaInputKey_KEYBOARD_SLASH] = "Slash", + [SkaInputKey_KEYBOARD_SEMICOLON] = "Semicolon", + [SkaInputKey_KEYBOARD_EQUALS] = "Equals", + [SkaInputKey_KEYBOARD_LEFT_BRACKET] = "Left Bracket", + [SkaInputKey_KEYBOARD_RIGHT_BRACKET] = "Right Bracket", + [SkaInputKey_KEYBOARD_BACKSLASH] = "Backslash", + [SkaInputKey_KEYBOARD_BACKQUOTE] = "Backquote", + [SkaInputKey_KEYBOARD_CAPS_LOCK] = "Caps Lock", + [SkaInputKey_KEYBOARD_SCROLL_LOCK] = "Scroll Lock", + [SkaInputKey_KEYBOARD_NUM_LOCK_CLEAR] = "Num Lock Clear", + [SkaInputKey_KEYBOARD_PRINT_SCREEN] = "Print Screen", + [SkaInputKey_KEYBOARD_PAUSE] = "Pause", + [SkaInputKey_KEYBOARD_KEYPAD_0] = "Keypad 0", + [SkaInputKey_KEYBOARD_KEYPAD_1] = "Keypad 1", + [SkaInputKey_KEYBOARD_KEYPAD_2] = "Keypad 2", + [SkaInputKey_KEYBOARD_KEYPAD_3] = "Keypad 3", + [SkaInputKey_KEYBOARD_KEYPAD_4] = "Keypad 4", + [SkaInputKey_KEYBOARD_KEYPAD_5] = "Keypad 5", + [SkaInputKey_KEYBOARD_KEYPAD_6] = "Keypad 6", + [SkaInputKey_KEYBOARD_KEYPAD_7] = "Keypad 7", + [SkaInputKey_KEYBOARD_KEYPAD_8] = "Keypad 8", + [SkaInputKey_KEYBOARD_KEYPAD_9] = "Keypad 9", + [SkaInputKey_KEYBOARD_KEYPAD_PERIOD] = "Keypad Period", + [SkaInputKey_KEYBOARD_KEYPAD_DIVIDE] = "Keypad Divide", + [SkaInputKey_KEYBOARD_KEYPAD_MULTIPLY] = "Keypad Multiply", + [SkaInputKey_KEYBOARD_KEYPAD_MINUS] = "Keypad Minus", + [SkaInputKey_KEYBOARD_KEYPAD_PLUS] = "Keypad Plus", + [SkaInputKey_KEYBOARD_KEYPAD_ENTER] = "Keypad Enter", + [SkaInputKey_KEYBOARD_KEYPAD_EQUALS] = "Keypad Equals", + [SkaInputKey_KEYBOARD_LEFT_CONTROL] = "Left Control", + [SkaInputKey_KEYBOARD_LEFT_SHIFT] = "Left Shift", + [SkaInputKey_KEYBOARD_LEFT_ALT] = "Left Alt", + [SkaInputKey_KEYBOARD_LEFT_GUI] = "Left GUI", + [SkaInputKey_KEYBOARD_RIGHT_CONTROL] = "Right Control", + [SkaInputKey_KEYBOARD_RIGHT_SHIFT] = "Right Shift", + [SkaInputKey_KEYBOARD_RIGHT_ALT] = "Right Alt", + [SkaInputKey_KEYBOARD_RIGHT_GUI] = "Right GUI", + [SkaInputKey_KEYBOARD_APPLICATION] = "Application", + [SkaInputKey_KEYBOARD_NUM_0] = "0", + [SkaInputKey_KEYBOARD_NUM_1] = "1", + [SkaInputKey_KEYBOARD_NUM_2] = "2", + [SkaInputKey_KEYBOARD_NUM_3] = "3", + [SkaInputKey_KEYBOARD_NUM_4] = "4", + [SkaInputKey_KEYBOARD_NUM_5] = "5", + [SkaInputKey_KEYBOARD_NUM_6] = "6", + [SkaInputKey_KEYBOARD_NUM_7] = "7", + [SkaInputKey_KEYBOARD_NUM_8] = "8", + [SkaInputKey_KEYBOARD_NUM_9] = "9", + [SkaInputKey_KEYBOARD_A] = "A", + [SkaInputKey_KEYBOARD_B] = "B", + [SkaInputKey_KEYBOARD_C] = "C", + [SkaInputKey_KEYBOARD_D] = "D", + [SkaInputKey_KEYBOARD_E] = "E", + [SkaInputKey_KEYBOARD_F] = "F", + [SkaInputKey_KEYBOARD_G] = "G", + [SkaInputKey_KEYBOARD_H] = "H", + [SkaInputKey_KEYBOARD_I] = "I", + [SkaInputKey_KEYBOARD_J] = "J", + [SkaInputKey_KEYBOARD_K] = "K", + [SkaInputKey_KEYBOARD_L] = "L", + [SkaInputKey_KEYBOARD_M] = "M", + [SkaInputKey_KEYBOARD_N] = "N", + [SkaInputKey_KEYBOARD_O] = "O", + [SkaInputKey_KEYBOARD_P] = "P", + [SkaInputKey_KEYBOARD_Q] = "Q", + [SkaInputKey_KEYBOARD_R] = "R", + [SkaInputKey_KEYBOARD_S] = "S", + [SkaInputKey_KEYBOARD_T] = "T", + [SkaInputKey_KEYBOARD_U] = "U", + [SkaInputKey_KEYBOARD_V] = "V", + [SkaInputKey_KEYBOARD_W] = "W", + [SkaInputKey_KEYBOARD_X] = "X", + [SkaInputKey_KEYBOARD_Y] = "Y", + [SkaInputKey_KEYBOARD_Z] = "Z", + [SkaInputKey_KEYBOARD_F1] = "F1", + [SkaInputKey_KEYBOARD_F2] = "F2", + [SkaInputKey_KEYBOARD_F3] = "F3", + [SkaInputKey_KEYBOARD_F4] = "F4", + [SkaInputKey_KEYBOARD_F5] = "F5", + [SkaInputKey_KEYBOARD_F6] = "F6", + [SkaInputKey_KEYBOARD_F7] = "F7", + [SkaInputKey_KEYBOARD_F8] = "F8", + [SkaInputKey_KEYBOARD_F9] = "F9", + [SkaInputKey_KEYBOARD_F10] = "F10", + [SkaInputKey_KEYBOARD_F11] = "F11", + [SkaInputKey_KEYBOARD_F12] = "F12", + [SkaInputKey_KEYBOARD_F13] = "F13", + [SkaInputKey_KEYBOARD_F14] = "F14", + [SkaInputKey_KEYBOARD_F15] = "F15", + [SkaInputKey_KEYBOARD_F16] = "F16", + [SkaInputKey_KEYBOARD_F17] = "F17", + [SkaInputKey_KEYBOARD_F18] = "F18", + [SkaInputKey_KEYBOARD_F19] = "F19", + [SkaInputKey_KEYBOARD_F20] = "F20", + [SkaInputKey_KEYBOARD_F21] = "F21", + [SkaInputKey_KEYBOARD_F22] = "F22", + [SkaInputKey_KEYBOARD_F23] = "F23", + [SkaInputKey_KEYBOARD_F24] = "F24", + [SkaInputKey_KEYBOARD_APP_FORWARD] = "App Forward", + [SkaInputKey_KEYBOARD_APP_BACK] = "App Back", + // Mouse + [SkaInputKey_MOUSE_BUTTON_LEFT] = "Mouse Button Left", + [SkaInputKey_MOUSE_BUTTON_RIGHT] = "Mouse Button Right", + [SkaInputKey_MOUSE_BUTTON_MIDDLE] = "Mouse Button Middle", + }; + return keyNames[key]; +} + +SkaInputKey ska_input_string_to_key(const char* keyName) { + for (SkaInputKey key = 0; key < SkaInputKey_NUMBER_OF_KEYS; ++key) { + if (strcmp(keyName, ska_input_key_to_string(key)) == 0) { + return key; + } + } + return SkaInputKey_INVALID; // Return invalid if not found +} + +bool ska_input_is_keyboard_key(SkaInputKey key) { + return key >= SKA_INPUT_KEY_KEYBOARD_ENUM_START && key <= SKA_INPUT_KEY_KEYBOARD_ENUM_END; +} + +bool ska_input_is_mouse_key(SkaInputKey key) { + return key >= SKA_INPUT_KEY_MOUSE_ENUM_START && key <= SKA_INPUT_KEY_MOUSE_ENUM_END; +} + +bool ska_input_is_gamepad_key(SkaInputKey key) { + return key >= SKA_INPUT_KEY_GAMEPAD_ENUM_START && key <= SKA_INPUT_KEY_GAMEPAD_ENUM_END; +} + +// Events +void ska_input_register_gamepad_added_event(SkaInputDeviceIndex deviceIndex) {} + +void ska_input_register_gamepad_removed_event(SkaInputDeviceIndex deviceIndex) { + ska_input_reset_gamepad(deviceIndex); +} + +void ska_input_register_input_event3(SkaInputSourceType sourceType, SkaInputKey key, SkaInputTriggerType triggerType) { + ska_input_register_input_event2(sourceType, key, triggerType, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); +} + +void ska_input_register_input_event2(SkaInputSourceType sourceType, SkaInputKey key, SkaInputTriggerType triggerType, SkaInputDeviceIndex deviceIndex) { + ska_input_register_input_event(sourceType, key, triggerType, deviceIndex, 0.0f); +} + +void ska_input_register_input_event(SkaInputSourceType sourceType, SkaInputKey key, SkaInputTriggerType triggerType, SkaInputDeviceIndex deviceIndex, f32 gamepadAxisValue) { + SkaInputInteractionStatus interactionStatus = SkaInputInteractionStatus_PRESSED; + SkaInputKeyState* keyState = &inputState.inputKeyState[deviceIndex][key]; + + switch (triggerType) { + case SkaInputTriggerType_PRESSED: { + if (!keyState->isPressed) { + interactionStatus = SkaInputInteractionStatus_JUST_PRESSED; + keyState->isJustPressed = true; + SKA_ASSERT(inputState.cleanupKeyStateJustPressedCount + 1 <= SKA_INPUT_MAX_KEY_STATE_CLEANUP_SIZE); + inputState.cleanupKeyStateJustPressed[inputState.cleanupKeyStateJustPressedCount++] = (SkaInputStateCleanup) { .key = key, .deviceIndex = deviceIndex }; + } else { + keyState->isJustPressed = false; + } + keyState->isPressed = true; + keyState->isJustReleased = false; + keyState->strength = 1.0f; + break; + } + case SkaInputTriggerType_RELEASED: { + if (keyState->isJustReleased) { + return; + } + keyState->isPressed = false; + keyState->isJustPressed = false; + keyState->isJustReleased = true; + keyState->strength = 0.0f; + interactionStatus = SkaInputInteractionStatus_JUST_RELEASED; + SKA_ASSERT(inputState.cleanupKeyStateJustReleasedCount + 1 <= SKA_INPUT_MAX_KEY_STATE_CLEANUP_SIZE); + inputState.cleanupKeyStateJustReleased[inputState.cleanupKeyStateJustReleasedCount++] = (SkaInputStateCleanup) { .key = key, .deviceIndex = deviceIndex }; + break; + } + case SkaInputTriggerType_AXIS_IN_MOTION: { + if (!keyState->isPressed) { + interactionStatus = SkaInputInteractionStatus_AXIS_STARTED_MOTION; + keyState->isJustPressed = true; + SKA_ASSERT(inputState.cleanupKeyStateJustPressedCount + 1 <= SKA_INPUT_MAX_KEY_STATE_CLEANUP_SIZE); + inputState.cleanupKeyStateJustPressed[inputState.cleanupKeyStateJustPressedCount++] = (SkaInputStateCleanup) { .key = key, .deviceIndex = deviceIndex }; + } else { + interactionStatus = SkaInputInteractionStatus_AXIS_IN_MOTION; + keyState->isJustPressed = false; + } + keyState->isPressed = true; + keyState->isJustReleased = false; + keyState->strength = gamepadAxisValue; + + if (key != SkaInputKey_GAMEPAD_LEFT_TRIGGER && key != SkaInputKey_GAMEPAD_RIGHT_TRIGGER) { + update_axis_key_state(key, interactionStatus, gamepadAxisValue, deviceIndex); + } + break; + } + case SkaInputTriggerType_AXIS_STOPPED_MOTION: { + if (keyState->isJustReleased) { + return; + } + interactionStatus = SkaInputInteractionStatus_AXIS_STOPPED_MOTION; + keyState->isPressed = false; + keyState->isJustPressed = false; + keyState->isJustReleased = true; + keyState->strength = 0.0f; + SKA_ASSERT(inputState.cleanupKeyStateJustReleasedCount + 1 <= SKA_INPUT_MAX_KEY_STATE_CLEANUP_SIZE); + inputState.cleanupKeyStateJustReleased[inputState.cleanupKeyStateJustReleasedCount++] = (SkaInputStateCleanup) { .key = key, .deviceIndex = deviceIndex }; + + if (key != SkaInputKey_GAMEPAD_LEFT_TRIGGER && key != SkaInputKey_GAMEPAD_RIGHT_TRIGGER) { + update_axis_key_state(key, interactionStatus, gamepadAxisValue, deviceIndex); + } + break; + } + case SkaInputTriggerType_DEVICE_ADDED: + case SkaInputTriggerType_DEVICE_REMOVED: + case SkaInputTriggerType_INVALID: + break; + } + +// const SkaInputEvent inputEvent = (SkaInputEvent) { .sourceType = sourceType, .interactionStatus = interactionStatus, .key = key, .deviceIndex = deviceIndex, gamepadAxisValue = gamepadAxisValue }; +} + +bool ska_input_is_key_pressed(SkaInputKey key, SkaInputDeviceIndex deviceIndex) { + return inputState.inputKeyState[deviceIndex][key].isPressed; +} +bool ska_input_is_key_just_pressed(SkaInputKey key, SkaInputDeviceIndex deviceIndex) { + return inputState.inputKeyState[deviceIndex][key].isJustPressed; +} +bool ska_input_is_key_just_released(SkaInputKey key, SkaInputDeviceIndex deviceIndex) { + return inputState.inputKeyState[deviceIndex][key].isJustReleased; +} +f32 ska_input_get_key_strength(SkaInputKey key, SkaInputDeviceIndex deviceIndex) { + return inputState.inputKeyState[deviceIndex][key].strength; +} + +SkaVector2 ska_input_get_axis_input(SkaInputAxis axis, SkaInputDeviceIndex deviceIndex) { + struct SkaAxis2DInputKeys { + SkaInputKey x; + SkaInputKey y; + }; + + const struct SkaAxis2DInputKeys axisKeys = axis == SkaInputAxis_LEFT + ? (struct SkaAxis2DInputKeys) { .x = SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X, .y = SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y } + : (struct SkaAxis2DInputKeys) { .x = SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X, .y = SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_Y }; + const SkaInputKeyState* xKeyState = &inputState.inputKeyState[deviceIndex][axisKeys.x]; + const SkaInputKeyState* yKeyState = &inputState.inputKeyState[deviceIndex][axisKeys.y]; + return (SkaVector2) { .x = xKeyState->strength, .y = yKeyState->strength }; +} + +SkaMouse* ska_input_get_mouse() { + return &globalMouse; +} + +// Input Action +SkaInputActionHandle ska_input_add_input_action(const char* actionName, const SkaInputActionValue* actionValues, SkaInputDeviceIndex deviceIndex) { + SkaInputActionHandle actionHandle = ska_input_find_input_action_handle(actionName, deviceIndex); + if (actionHandle == SKA_INPUT_INVALID_INPUT_ACTION_HANDLE) { + SKA_ASSERT(inputState.inputActionHandleIndex + 1 < SKA_INPUT_MAX_INPUT_ACTIONS); + actionHandle = inputState.inputActionHandleIndex++; + SkaInputActionData* actionData = &inputState.inputActionData[deviceIndex][actionHandle]; + actionData->handle = actionHandle; + actionData->action.name = ska_strdup(actionName); + actionData->action.actionValuesCount = 0; + } + + SkaInputActionData* actionData = &inputState.inputActionData[deviceIndex][actionHandle]; + for (usize i = 0; i < SKA_INPUT_MAX_INPUT_ACTION_VALUES; i++) { + if (!actionValues[i].key) { + break; + } + SKA_ASSERT(actionData->action.actionValuesCount + 1 < SKA_INPUT_MAX_INPUT_ACTION_VALUES); + actionData->action.actionValues[actionData->action.actionValuesCount++] = actionValues[i]; + } + return actionHandle; +} + +SkaInputAction* ska_input_get_input_action(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex) { + SkaInputActionData* actionData = &inputState.inputActionData[deviceIndex][handle]; + if (actionData->handle) { + return &actionData->action; + } + return NULL; +} + +bool ska_input_remove_input_action(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex) { + SkaInputActionData* actionData = &inputState.inputActionData[deviceIndex][handle]; + if (actionData->handle != SKA_INPUT_INVALID_INPUT_ACTION_HANDLE) { + SKA_FREE(actionData->action.name); + actionData->action.name = NULL; + actionData->handle = SKA_INPUT_INVALID_INPUT_ACTION_HANDLE; + return true; + } + return false; +} + +SkaInputActionHandle ska_input_find_input_action_handle(const char* actionName, SkaInputDeviceIndex deviceIndex) { + for (SkaInputActionHandle handle = 0; handle < SKA_INPUT_MAX_INPUT_ACTIONS; handle++) { + SkaInputActionData* actionData = &inputState.inputActionData[deviceIndex][handle]; + // TODO: Shouldn't have to check for NULL name as handle should be enough + if (actionData->handle == SKA_INPUT_INVALID_INPUT_ACTION_HANDLE || actionData->action.name == NULL) { + continue; + } + if (strcmp(actionData->action.name, actionName) == 0) { + return actionData->handle; + } + } + return SKA_INPUT_INVALID_INPUT_ACTION_HANDLE; +} + +bool ska_input_is_input_action_pressed(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex) { + const SkaInputActionData* actionData = &inputState.inputActionData[deviceIndex][handle]; + for (usize i = 0; i < actionData->action.actionValuesCount; i++) { + const SkaInputActionValue* actionValue = &actionData->action.actionValues[i]; + if (ska_input_is_key_pressed(actionValue->key, deviceIndex)) { + return true; + } + } + return false; +} + +bool ska_input_is_input_action_just_pressed(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex) { + const SkaInputActionData* actionData = &inputState.inputActionData[deviceIndex][handle]; + for (usize i = 0; i < actionData->action.actionValuesCount; i++) { + const SkaInputActionValue* actionValue = &actionData->action.actionValues[i]; + if (ska_input_is_key_just_pressed(actionValue->key, deviceIndex)) { + return true; + } + } + return false; +} + +bool ska_input_is_input_action_just_released(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex) { + const SkaInputActionData* actionData = &inputState.inputActionData[deviceIndex][handle]; + for (usize i = 0; i < actionData->action.actionValuesCount; i++) { + const SkaInputActionValue* actionValue = &actionData->action.actionValues[i]; + if (ska_input_is_key_just_released(actionValue->key, deviceIndex)) { + return true; + } + } + return false; +} + +f32 ska_input_get_input_action_strength(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex) { + const SkaInputActionData* actionData = &inputState.inputActionData[deviceIndex][handle]; + for (usize i = 0; i < actionData->action.actionValuesCount; i++) { + const SkaInputActionValue* actionValue = &actionData->action.actionValues[i]; + const f32 keyStrength = ska_input_get_key_strength(actionValue->key, deviceIndex); + if (keyStrength >= actionValue->strengthThreshold) { + return keyStrength; + } + } + return 0.0f; +} + +void ska_input_new_frame() { + for (usize i = 0; i < inputState.cleanupKeyStateJustPressedCount; i++) { + const SkaInputStateCleanup* stateCleanup = &inputState.cleanupKeyStateJustPressed[i]; + SkaInputKeyState* keyState = &inputState.inputKeyState[stateCleanup->deviceIndex][stateCleanup->key]; + keyState->isJustPressed = false; + } + for (usize i = 0; i < inputState.cleanupKeyStateJustReleasedCount; i++) { + const SkaInputStateCleanup* stateCleanup = &inputState.cleanupKeyStateJustReleased[i]; + SkaInputKeyState* keyState = &inputState.inputKeyState[stateCleanup->deviceIndex][stateCleanup->key]; + keyState->isJustReleased = false; + } + inputState.cleanupKeyStateJustPressedCount = 0; + inputState.cleanupKeyStateJustReleasedCount = 0; +} + +void ska_input_reset_gamepad(SkaInputDeviceIndex deviceIndex) { + SKA_INPUT_KEY_GAMEPAD_FOR_EACH(key) { + inputState.inputKeyState[deviceIndex][key] = (SkaInputKeyState){0}; + } +} + +void ska_input_reset(SkaInputDeviceIndex deviceIndex) { + inputState = (SkaInputState)DEFAULT_INPUT_STATE; +} + +// Private +SkaInputKey get_key_from_2d_axis_key(SkaInputKey axis2DKey, SkaAxisInputValues* axisInputValues, f32 axisValue) { + switch (axis2DKey) { + case SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X: { + const f32 activeValue = axisInputValues->left.x != 0.0f ? axisInputValues->left.x : axisValue; + return activeValue > 0 ? SkaInputKey_GAMEPAD_LEFT_ANALOG_RIGHT : SkaInputKey_GAMEPAD_LEFT_ANALOG_LEFT; + } + case SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y: { + const f32 activeValue = axisInputValues->left.y != 0.0f ? axisInputValues->left.y : axisValue; + return activeValue > 0 ? SkaInputKey_GAMEPAD_LEFT_ANALOG_DOWN : SkaInputKey_GAMEPAD_LEFT_ANALOG_UP; + } + case SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X: { + const f32 activeValue = axisInputValues->right.x != 0.0f ? axisInputValues->right.x : axisValue; + return activeValue > 0 ? SkaInputKey_GAMEPAD_RIGHT_ANALOG_RIGHT : SkaInputKey_GAMEPAD_RIGHT_ANALOG_LEFT; + } + case SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_Y: { + const f32 activeValue = axisInputValues->right.y != 0.0f ? axisInputValues->right.y : axisValue; + return activeValue > 0 ? SkaInputKey_GAMEPAD_RIGHT_ANALOG_DOWN : SkaInputKey_GAMEPAD_RIGHT_ANALOG_UP; + } + default: { + SKA_ASSERT_FMT(false, "Not a valid axis input key!"); + return SkaInputKey_INVALID; + } + } +} + +void set_prev_input_axis_value(SkaInputKey key, SkaAxisInputValues* axisInputValues, f32 axisValue) { + switch (key) { + case SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X: { + axisInputValues->left.x = axisValue; + break; + } + case SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y: { + axisInputValues->left.y = axisValue; + break; + } + case SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X: { + axisInputValues->right.x = axisValue; + break; + } + case SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_Y: { + axisInputValues->right.y = axisValue; + break; + } + default: { + SKA_ASSERT_FMT(false, "Not a valid axis input key!"); + } + } +} + +void update_axis_key_state(SkaInputKey key, SkaInputInteractionStatus interactionStatus, f32 axisValue, SkaInputDeviceIndex deviceIndex) { + SkaAxisInputValues* prevAxisInput = &inputState.prevAxisInputs[deviceIndex]; + const SkaInputKey axisKey = get_key_from_2d_axis_key(key, prevAxisInput, axisValue); + SkaInputKeyState* axisKeyState = &inputState.inputKeyState[deviceIndex][axisKey]; + switch (interactionStatus) { + case SkaInputInteractionStatus_AXIS_STARTED_MOTION: + case SkaInputInteractionStatus_AXIS_IN_MOTION: { + axisKeyState->isPressed = true; + if (interactionStatus == SkaInputInteractionStatus_AXIS_STARTED_MOTION) { + axisKeyState->isJustPressed = true; + SKA_ASSERT(inputState.cleanupKeyStateJustPressedCount + 1 <= SKA_INPUT_MAX_KEY_STATE_CLEANUP_SIZE); + inputState.cleanupKeyStateJustPressed[inputState.cleanupKeyStateJustPressedCount++] = (SkaInputStateCleanup) { .key = key, .deviceIndex = deviceIndex }; + } else { + axisKeyState->isJustPressed = false; + } + axisKeyState->isJustReleased = false; + axisKeyState->strength = (f32)fabs(axisValue); + set_prev_input_axis_value(key, prevAxisInput, axisValue); + break; + } + case SkaInputInteractionStatus_AXIS_STOPPED_MOTION: { + axisKeyState->isPressed = false; + axisKeyState->isJustPressed = false; + axisKeyState->isJustReleased = true; + axisKeyState->strength = 0.0f; + set_prev_input_axis_value(key, prevAxisInput, 0.0f); + SKA_ASSERT(inputState.cleanupKeyStateJustReleasedCount + 1 <= SKA_INPUT_MAX_KEY_STATE_CLEANUP_SIZE); + inputState.cleanupKeyStateJustReleased[inputState.cleanupKeyStateJustReleasedCount++] = (SkaInputStateCleanup) { .key = key, .deviceIndex = deviceIndex }; + break; + } + default: { + SKA_ASSERT_FMT(false, "Invalid interaction status fo 2d axis key when trying to update key state!"); + } + } +} + +#endif // if SKA_INPUT diff --git a/seika/input/input.h b/seika/input/input.h new file mode 100644 index 0000000..64336a1 --- /dev/null +++ b/seika/input/input.h @@ -0,0 +1,296 @@ +#pragma once + +#if SKA_INPUT + +#ifdef __cplusplus +extern "C" { +#endif + +#include "seika/math/math.h" + +typedef int32 SkaInputDeviceIndex; +typedef uint32 SkaInputSubscriberHandle; +typedef uint32 SkaInputActionHandle; +typedef float SkaInputKeyStrength; + +#define SKA_INPUT_MAX_DEVICES ((SkaInputDeviceIndex)8) +#define SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX ((SkaInputDeviceIndex)0) +#define SKA_INPUT_MAX_INPUT_ACTIONS ((SkaInputActionHandle)128) +#define SKA_INPUT_INVALID_INPUT_ACTION_HANDLE ((SkaInputActionHandle)-1) +#define SKA_INPUT_MAX_INPUT_ACTION_VALUES 8 + +typedef enum SkaInputSourceType { + SkaInputSourceType_INVALID, + SkaInputSourceType_KEYBOARD, + SkaInputSourceType_GAMEPAD, + SkaInputSourceType_MOUSE, +} SkaInputSourceType; + +typedef enum SkaInputTriggerType { + SkaInputTriggerType_INVALID, + SkaInputTriggerType_PRESSED, + SkaInputTriggerType_RELEASED, + SkaInputTriggerType_AXIS_IN_MOTION, + SkaInputTriggerType_AXIS_STOPPED_MOTION, + SkaInputTriggerType_DEVICE_ADDED, + SkaInputTriggerType_DEVICE_REMOVED, +} SkaInputTriggerType; + +typedef enum SkaInputInteractionStatus { + SkaInputInteractionStatus_PRESSED, + SkaInputInteractionStatus_JUST_PRESSED, + SkaInputInteractionStatus_JUST_RELEASED, + SkaInputInteractionStatus_AXIS_STARTED_MOTION, + SkaInputInteractionStatus_AXIS_IN_MOTION, + SkaInputInteractionStatus_AXIS_STOPPED_MOTION, +} SkaInputInteractionStatus; + +typedef enum SkaInputKey { + SkaInputKey_INVALID, + // Gamepad + SkaInputKey_GAMEPAD_DPAD_DOWN, + SkaInputKey_GAMEPAD_DPAD_UP, + SkaInputKey_GAMEPAD_DPAD_LEFT, + SkaInputKey_GAMEPAD_DPAD_RIGHT, + SkaInputKey_GAMEPAD_FACE_BUTTON_NORTH, // XBOX Y + SkaInputKey_GAMEPAD_FACE_BUTTON_SOUTH, // XBOX A + SkaInputKey_GAMEPAD_FACE_BUTTON_EAST, // XBOX B + SkaInputKey_GAMEPAD_FACE_BUTTON_WEST, // XBOX X + SkaInputKey_GAMEPAD_START, + SkaInputKey_GAMEPAD_BACK, + SkaInputKey_GAMEPAD_LEFT_SHOULDER, // PS L1 + SkaInputKey_GAMEPAD_LEFT_TRIGGER, // PS L2 + SkaInputKey_GAMEPAD_LEFT_ANALOG_BUTTON, // PS L3 + SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X, + SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y, + SkaInputKey_GAMEPAD_RIGHT_SHOULDER, // PS R1 + SkaInputKey_GAMEPAD_RIGHT_TRIGGER, // PS R2 + SkaInputKey_GAMEPAD_RIGHT_ANALOG_BUTTON, // PS R3 + SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X, + SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_Y, + // Keeping these separate as 'RegisterInputEvent' should only use 'SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X', 'SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y', + // 'SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X', and 'SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_Y'. + // The key states for these keys will be updated automatically by the input system. + SkaInputKey_GAMEPAD_LEFT_ANALOG_LEFT, + SkaInputKey_GAMEPAD_LEFT_ANALOG_RIGHT, + SkaInputKey_GAMEPAD_LEFT_ANALOG_UP, + SkaInputKey_GAMEPAD_LEFT_ANALOG_DOWN, + SkaInputKey_GAMEPAD_RIGHT_ANALOG_LEFT, + SkaInputKey_GAMEPAD_RIGHT_ANALOG_RIGHT, + SkaInputKey_GAMEPAD_RIGHT_ANALOG_UP, + SkaInputKey_GAMEPAD_RIGHT_ANALOG_DOWN, + + // Keyboard + SkaInputKey_KEYBOARD_TAB, + SkaInputKey_KEYBOARD_LEFT, + SkaInputKey_KEYBOARD_RIGHT, + SkaInputKey_KEYBOARD_UP, + SkaInputKey_KEYBOARD_DOWN, + SkaInputKey_KEYBOARD_PAGE_DOWN, + SkaInputKey_KEYBOARD_PAGE_UP, + SkaInputKey_KEYBOARD_HOME, + SkaInputKey_KEYBOARD_END, + SkaInputKey_KEYBOARD_INSERT, + SkaInputKey_KEYBOARD_DELETE, + SkaInputKey_KEYBOARD_BACKSPACE, + SkaInputKey_KEYBOARD_SPACE, + SkaInputKey_KEYBOARD_RETURN, + SkaInputKey_KEYBOARD_ESCAPE, + SkaInputKey_KEYBOARD_QUOTE, + SkaInputKey_KEYBOARD_COMMA, + SkaInputKey_KEYBOARD_MINUS, + SkaInputKey_KEYBOARD_PERIOD, + SkaInputKey_KEYBOARD_SLASH, + SkaInputKey_KEYBOARD_SEMICOLON, + SkaInputKey_KEYBOARD_EQUALS, + SkaInputKey_KEYBOARD_LEFT_BRACKET, + SkaInputKey_KEYBOARD_RIGHT_BRACKET, + SkaInputKey_KEYBOARD_BACKSLASH, + SkaInputKey_KEYBOARD_BACKQUOTE, + SkaInputKey_KEYBOARD_CAPS_LOCK, + SkaInputKey_KEYBOARD_SCROLL_LOCK, + SkaInputKey_KEYBOARD_NUM_LOCK_CLEAR, + SkaInputKey_KEYBOARD_PRINT_SCREEN, + SkaInputKey_KEYBOARD_PAUSE, + SkaInputKey_KEYBOARD_KEYPAD_0, + SkaInputKey_KEYBOARD_KEYPAD_1, + SkaInputKey_KEYBOARD_KEYPAD_2, + SkaInputKey_KEYBOARD_KEYPAD_3, + SkaInputKey_KEYBOARD_KEYPAD_4, + SkaInputKey_KEYBOARD_KEYPAD_5, + SkaInputKey_KEYBOARD_KEYPAD_6, + SkaInputKey_KEYBOARD_KEYPAD_7, + SkaInputKey_KEYBOARD_KEYPAD_8, + SkaInputKey_KEYBOARD_KEYPAD_9, + SkaInputKey_KEYBOARD_KEYPAD_PERIOD, + SkaInputKey_KEYBOARD_KEYPAD_DIVIDE, + SkaInputKey_KEYBOARD_KEYPAD_MULTIPLY, + SkaInputKey_KEYBOARD_KEYPAD_MINUS, + SkaInputKey_KEYBOARD_KEYPAD_PLUS, + SkaInputKey_KEYBOARD_KEYPAD_ENTER, + SkaInputKey_KEYBOARD_KEYPAD_EQUALS, + SkaInputKey_KEYBOARD_LEFT_CONTROL, + SkaInputKey_KEYBOARD_LEFT_SHIFT, + SkaInputKey_KEYBOARD_LEFT_ALT, + SkaInputKey_KEYBOARD_LEFT_GUI, + SkaInputKey_KEYBOARD_RIGHT_CONTROL, + SkaInputKey_KEYBOARD_RIGHT_SHIFT, + SkaInputKey_KEYBOARD_RIGHT_ALT, + SkaInputKey_KEYBOARD_RIGHT_GUI, + SkaInputKey_KEYBOARD_APPLICATION, + SkaInputKey_KEYBOARD_NUM_0, + SkaInputKey_KEYBOARD_NUM_1, + SkaInputKey_KEYBOARD_NUM_2, + SkaInputKey_KEYBOARD_NUM_3, + SkaInputKey_KEYBOARD_NUM_4, + SkaInputKey_KEYBOARD_NUM_5, + SkaInputKey_KEYBOARD_NUM_6, + SkaInputKey_KEYBOARD_NUM_7, + SkaInputKey_KEYBOARD_NUM_8, + SkaInputKey_KEYBOARD_NUM_9, + SkaInputKey_KEYBOARD_A, + SkaInputKey_KEYBOARD_B, + SkaInputKey_KEYBOARD_C, + SkaInputKey_KEYBOARD_D, + SkaInputKey_KEYBOARD_E, + SkaInputKey_KEYBOARD_F, + SkaInputKey_KEYBOARD_G, + SkaInputKey_KEYBOARD_H, + SkaInputKey_KEYBOARD_I, + SkaInputKey_KEYBOARD_J, + SkaInputKey_KEYBOARD_K, + SkaInputKey_KEYBOARD_L, + SkaInputKey_KEYBOARD_M, + SkaInputKey_KEYBOARD_N, + SkaInputKey_KEYBOARD_O, + SkaInputKey_KEYBOARD_P, + SkaInputKey_KEYBOARD_Q, + SkaInputKey_KEYBOARD_R, + SkaInputKey_KEYBOARD_S, + SkaInputKey_KEYBOARD_T, + SkaInputKey_KEYBOARD_U, + SkaInputKey_KEYBOARD_V, + SkaInputKey_KEYBOARD_W, + SkaInputKey_KEYBOARD_X, + SkaInputKey_KEYBOARD_Y, + SkaInputKey_KEYBOARD_Z, + SkaInputKey_KEYBOARD_F1, + SkaInputKey_KEYBOARD_F2, + SkaInputKey_KEYBOARD_F3, + SkaInputKey_KEYBOARD_F4, + SkaInputKey_KEYBOARD_F5, + SkaInputKey_KEYBOARD_F6, + SkaInputKey_KEYBOARD_F7, + SkaInputKey_KEYBOARD_F8, + SkaInputKey_KEYBOARD_F9, + SkaInputKey_KEYBOARD_F10, + SkaInputKey_KEYBOARD_F11, + SkaInputKey_KEYBOARD_F12, + SkaInputKey_KEYBOARD_F13, + SkaInputKey_KEYBOARD_F14, + SkaInputKey_KEYBOARD_F15, + SkaInputKey_KEYBOARD_F16, + SkaInputKey_KEYBOARD_F17, + SkaInputKey_KEYBOARD_F18, + SkaInputKey_KEYBOARD_F19, + SkaInputKey_KEYBOARD_F20, + SkaInputKey_KEYBOARD_F21, + SkaInputKey_KEYBOARD_F22, + SkaInputKey_KEYBOARD_F23, + SkaInputKey_KEYBOARD_F24, + SkaInputKey_KEYBOARD_APP_FORWARD, + SkaInputKey_KEYBOARD_APP_BACK, + + // Mouse + SkaInputKey_MOUSE_BUTTON_LEFT, + SkaInputKey_MOUSE_BUTTON_RIGHT, + SkaInputKey_MOUSE_BUTTON_MIDDLE, + + SkaInputKey_NUMBER_OF_KEYS +} SkaInputKey; + +#define SKA_INPUT_KEY_GAMEPAD_ENUM_START SkaInputKey_GAMEPAD_DPAD_DOWN +#define SKA_INPUT_KEY_GAMEPAD_ENUM_END SkaInputKey_GAMEPAD_RIGHT_ANALOG_DOWN +#define SKA_INPUT_KEY_KEYBOARD_ENUM_START SkaInputKey_KEYBOARD_TAB +#define SKA_INPUT_KEY_KEYBOARD_ENUM_END SkaInputKey_KEYBOARD_APP_BACK +#define SKA_INPUT_KEY_MOUSE_ENUM_START SkaInputKey_MOUSE_BUTTON_LEFT +#define SKA_INPUT_KEY_MOUSE_ENUM_END SkaInputKey_MOUSE_BUTTON_MIDDLE + +#define SKA_INPUT_KEY_GAMEPAD_COUNT (SKA_INPUT_KEY_GAMEPAD_ENUM_END - SKA_INPUT_KEY_GAMEPAD_ENUM_START) +#define SKA_INPUT_KEY_KEYBOARD_COUNT (SKA_INPUT_KEY_KEYBOARD_ENUM_END - SKA_INPUT_KEY_KEYBOARD_ENUM_START) +#define SKA_INPUT_KEY_MOUSE_COUNT (SKA_INPUT_KEY_MOUSE_ENUM_END - SKA_INPUT_KEY_MOUSE_ENUM_START) + +#define SKA_INPUT_KEY_GAMEPAD_FOR_EACH(KeyName) for(SkaInputKey KeyName = SKA_INPUT_KEY_GAMEPAD_ENUM_START; KeyName <= SKA_INPUT_KEY_GAMEPAD_ENUM_END; KeyName++) +#define SKA_INPUT_KEY_KEYBOARD_FOR_EACH(KeyName) for(SkaInputKey KeyName = SKA_INPUT_KEY_KEYBOARD_ENUM_START; KeyName <= SKA_INPUT_KEY_KEYBOARD_ENUM_END; KeyName++) +#define SKA_INPUT_KEY_MOUSE_FOR_EACH(KeyName) for(SkaInputKey KeyName = SKA_INPUT_KEY_MOUSE_ENUM_START; KeyName <= SKA_INPUT_KEY_MOUSE_ENUM_END; KeyName++) + +typedef enum SkaInputAxis { + SkaInputAxis_LEFT, + SkaInputAxis_RIGHT, +} SkaInputAxis; + +typedef struct SkaMouse { + SkaVector2 position; +} SkaMouse; + +typedef struct SkaInputEvent { + SkaInputSourceType sourceType; + SkaInputInteractionStatus interactionStatus; + SkaInputKey key; + SkaInputDeviceIndex deviceIndex; + f32 gamepadAxisValue; +} SkaInputEvent; + +typedef struct SkaInputActionValue { + SkaInputKey key; + SkaInputKeyStrength strengthThreshold; +} SkaInputActionValue; + +typedef struct SkaInputAction { + char* name; + SkaInputActionValue actionValues[SKA_INPUT_MAX_INPUT_ACTION_VALUES]; + usize actionValuesCount; +} SkaInputAction; + +const char* ska_input_key_to_string(SkaInputKey key); +SkaInputKey ska_input_string_to_key(const char* keyName); + +bool ska_input_is_keyboard_key(SkaInputKey key); +bool ska_input_is_mouse_key(SkaInputKey key); +bool ska_input_is_gamepad_key(SkaInputKey key); + +// Events +void ska_input_register_gamepad_added_event(SkaInputDeviceIndex deviceIndex); +void ska_input_register_gamepad_removed_event(SkaInputDeviceIndex deviceIndex); +void ska_input_register_input_event(SkaInputSourceType sourceType, SkaInputKey key, SkaInputTriggerType triggerType, SkaInputDeviceIndex deviceIndex, f32 gamepadAxisValue); +void ska_input_register_input_event2(SkaInputSourceType sourceType, SkaInputKey key, SkaInputTriggerType triggerType, SkaInputDeviceIndex deviceIndex); +void ska_input_register_input_event3(SkaInputSourceType sourceType, SkaInputKey key, SkaInputTriggerType triggerType); + +bool ska_input_is_key_pressed(SkaInputKey key, SkaInputDeviceIndex deviceIndex); +bool ska_input_is_key_just_pressed(SkaInputKey key, SkaInputDeviceIndex deviceIndex); +bool ska_input_is_key_just_released(SkaInputKey key, SkaInputDeviceIndex deviceIndex); +f32 ska_input_get_key_strength(SkaInputKey key, SkaInputDeviceIndex deviceIndex); +SkaVector2 ska_input_get_axis_input(SkaInputAxis axis, SkaInputDeviceIndex deviceIndex); + +SkaMouse* ska_input_get_mouse(); + +// Input Action +SkaInputActionHandle ska_input_add_input_action(const char* actionName, const SkaInputActionValue* actionValues, SkaInputDeviceIndex deviceIndex); +SkaInputAction* ska_input_get_input_action(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex); +bool ska_input_remove_input_action(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex); +SkaInputActionHandle ska_input_find_input_action_handle(const char* actionName, SkaInputDeviceIndex deviceIndex); + +bool ska_input_is_input_action_pressed(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex); +bool ska_input_is_input_action_just_pressed(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex); +bool ska_input_is_input_action_just_released(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex); +f32 ska_input_get_input_action_strength(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex); + +void ska_input_new_frame(); +void ska_input_reset_gamepad(SkaInputDeviceIndex deviceIndex); +void ska_input_reset(SkaInputDeviceIndex deviceIndex); + +#ifdef __cplusplus +} +#endif + +#endif // if SKA_INPUT diff --git a/seika/input/sdl_gamepad_db.h b/seika/input/sdl_gamepad_db.h new file mode 100644 index 0000000..7b80af6 --- /dev/null +++ b/seika/input/sdl_gamepad_db.h @@ -0,0 +1,41991 @@ +#pragma once + +#if SKA_INPUT + +const unsigned char SKA_GAMEPAD_DB_HEX[] = { + 0x23, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x44, 0x42, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x53, 0x44, 0x4c, 0x20, 0x69, 0x6e, 0x20, 0x32, 0x2e, 0x30, 0x2e, + 0x31, 0x36, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x0d, 0x0a, 0x23, + 0x20, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x3a, 0x20, 0x68, 0x74, 0x74, + 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x61, 0x62, 0x6f, 0x6d, 0x64, 0x71, 0x2f, + 0x53, 0x44, 0x4c, 0x5f, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x44, 0x42, 0x0d, 0x0a, 0x0d, 0x0a, + 0x23, 0x20, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x33, 0x20, 0x49, 0x6e, + 0x20, 0x31, 0x20, 0x43, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x20, 0x42, 0x6f, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x61, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x33, 0x64, 0x52, + 0x75, 0x64, 0x64, 0x65, 0x72, 0x20, 0x46, 0x6f, 0x6f, 0x74, 0x20, 0x4d, + 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x64, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x34, + 0x50, 0x6c, 0x61, 0x79, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, + 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x34, 0x50, 0x6c, 0x61, 0x79, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x34, 0x50, 0x6c, 0x61, 0x79, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x33, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, + 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x34, 0x50, 0x6c, 0x61, 0x79, 0x20, 0x41, 0x64, 0x61, 0x70, + 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x64, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x34, 0x50, 0x6c, 0x61, 0x79, 0x20, 0x41, 0x64, 0x61, + 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x41, + 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20, + 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x44, + 0x6f, 0x67, 0x62, 0x6f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, + 0x46, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x31, 0x61, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x46, + 0x33, 0x30, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, + 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, + 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, + 0x69, 0x74, 0x44, 0x6f, 0x20, 0x46, 0x33, 0x30, 0x20, 0x41, 0x72, 0x63, + 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, + 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x61, 0x62, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, + 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x46, 0x33, 0x30, 0x20, 0x41, 0x72, + 0x63, 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x46, + 0x33, 0x30, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, 0x74, + 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x46, + 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x46, 0x43, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, + 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, + 0x74, 0x65, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x31, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, + 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x53, 0x45, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, + 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, + 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, + 0x64, 0x30, 0x30, 0x30, 0x30, 0x35, 0x31, 0x30, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, + 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, + 0x61, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x32, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, + 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, + 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, + 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x20, + 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x36, 0x35, 0x32, 0x38, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x20, + 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, + 0x44, 0x6f, 0x20, 0x4e, 0x36, 0x34, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x62, 0x39, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x62, 0x34, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x62, 0x38, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x36, 0x34, 0x2c, 0x2b, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x62, 0x39, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x62, 0x38, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x35, 0x31, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x61, 0x62, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, + 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, 0x53, 0x33, 0x30, 0x2c, 0x61, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x32, 0x61, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, + 0x44, 0x6f, 0x20, 0x4e, 0x45, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x4e, 0x45, 0x53, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, + 0x4e, 0x45, 0x53, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, + 0x53, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, + 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x35, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, + 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x50, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, + 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, + 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, + 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, + 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x33, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, + 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, + 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, + 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x38, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, + 0x44, 0x6f, 0x20, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, + 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, + 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, 0x33, 0x30, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, + 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, 0x33, 0x30, 0x20, + 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, + 0x43, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, + 0x61, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, + 0x43, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, + 0x43, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x61, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, + 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, + 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, + 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x39, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, + 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, + 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x61, 0x62, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x32, + 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, + 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x32, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, + 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, + 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, + 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, + 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, + 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, + 0x50, 0x72, 0x6f, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, + 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, + 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, + 0x72, 0x6f, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, + 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, + 0x69, 0x74, 0x44, 0x6f, 0x20, 0x55, 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x74, + 0x65, 0x20, 0x57, 0x69, 0x72, 0x65, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x32, 0x36, + 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x32, 0x34, + 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x32, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x55, 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, + 0x20, 0x57, 0x69, 0x72, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x55, 0x6c, 0x74, 0x69, + 0x6d, 0x61, 0x74, 0x65, 0x20, 0x57, 0x69, 0x72, 0x65, 0x6c, 0x65, 0x73, + 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, + 0x63, 0x31, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, + 0x65, 0x31, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, + 0x65, 0x32, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, + 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x32, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x32, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, + 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x41, 0x63, 0x6d, 0x65, 0x20, 0x47, 0x41, 0x30, 0x32, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x41, 0x63, 0x72, 0x75, 0x78, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, + 0x61, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, 0x66, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x41, 0x63, 0x74, 0x65, 0x63, 0x6b, 0x20, 0x41, 0x47, 0x4a, 0x20, 0x33, + 0x32, 0x30, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x31, 0x31, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x32, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x44, 0x54, 0x31, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, + 0x61, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x30, 0x38, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, + 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x50, 0x53, 0x33, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x50, 0x53, + 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, + 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, + 0x77, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x34, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, + 0x6c, 0x6f, 0x77, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, + 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, + 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, + 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x50, 0x53, 0x33, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, + 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, + 0x6c, 0x6f, 0x77, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, + 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x33, 0x39, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x61, 0x62, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, + 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, + 0x6c, 0x6f, 0x77, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, + 0x6b, 0x69, 0x73, 0x68, 0x6f, 0x70, 0x20, 0x43, 0x75, 0x73, 0x74, 0x6f, + 0x6d, 0x73, 0x20, 0x50, 0x53, 0x33, 0x36, 0x30, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x63, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x41, 0x6c, 0x69, 0x65, 0x6e, 0x77, 0x61, 0x72, 0x65, + 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x74, + 0x69, 0x62, 0x6c, 0x65, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x39, 0x31, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x39, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x6d, 0x61, 0x7a, 0x6f, + 0x6e, 0x20, 0x4c, 0x75, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, + 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x41, 0x6d, 0x61, 0x7a, 0x6f, 0x6e, 0x20, 0x4c, 0x75, + 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, + 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x72, 0x6d, 0x6f, + 0x72, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x39, 0x30, 0x62, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x34, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x53, 0x43, 0x49, 0x49, + 0x20, 0x53, 0x65, 0x61, 0x6d, 0x69, 0x63, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x39, 0x38, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x73, 0x74, + 0x72, 0x6f, 0x20, 0x43, 0x34, 0x30, 0x20, 0x54, 0x52, 0x20, 0x50, 0x53, + 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x41, 0x73, 0x74, 0x72, 0x6f, 0x20, 0x43, 0x69, + 0x74, 0x79, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x73, 0x74, 0x72, 0x6f, 0x20, 0x43, + 0x69, 0x74, 0x79, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x53, 0x55, 0x53, 0x20, 0x52, 0x4f, + 0x47, 0x20, 0x4b, 0x75, 0x6e, 0x61, 0x69, 0x20, 0x33, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x37, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x41, 0x53, 0x55, 0x53, 0x20, 0x52, 0x4f, 0x47, 0x20, 0x4b, 0x75, + 0x6e, 0x61, 0x69, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, + 0x20, 0x56, 0x43, 0x53, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, 0x20, 0x56, 0x43, 0x53, + 0x20, 0x4d, 0x6f, 0x64, 0x65, 0x72, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x34, + 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x33, 0x66, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, + 0x61, 0x74, 0x61, 0x72, 0x61, 0x6e, 0x67, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x35, 0x35, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, + 0x61, 0x74, 0x61, 0x72, 0x61, 0x6e, 0x67, 0x20, 0x50, 0x6c, 0x61, 0x79, + 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x33, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x61, 0x74, 0x74, + 0x61, 0x6c, 0x69, 0x66, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x36, 0x2c, 0x62, 0x3a, 0x62, 0x37, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, + 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, + 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, + 0x61, 0x74, 0x74, 0x6c, 0x65, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x34, + 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x66, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x42, 0x20, 0x30, 0x37, 0x30, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x61, 0x37, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x42, 0x44, 0x41, 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x69, 0x67, + 0x68, 0x74, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x63, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, 0x69, 0x74, 0x6f, + 0x6e, 0x67, 0x20, 0x47, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, 0x6c, 0x6b, 0x69, + 0x6e, 0x20, 0x4e, 0x6f, 0x73, 0x74, 0x72, 0x6f, 0x6d, 0x6f, 0x20, 0x4e, + 0x34, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x62, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x42, 0x65, 0x74, 0x6f, 0x70, 0x20, 0x32, 0x31, 0x32, 0x36, 0x46, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x62, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, 0x74, 0x6f, 0x70, 0x20, 0x42, 0x46, + 0x4d, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x62, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x33, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, 0x74, 0x6f, 0x70, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x62, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x32, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x42, 0x65, 0x74, 0x6f, 0x70, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x63, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, 0x74, + 0x6f, 0x70, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, 0x74, 0x6f, 0x70, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x35, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x42, 0x65, 0x74, 0x6f, 0x70, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, 0x74, + 0x6f, 0x70, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x42, 0x65, 0x74, 0x6f, 0x70, 0x20, 0x47, 0x61, 0x6d, 0x65, + 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x46, 0x20, 0x4f, 0x6e, + 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, + 0x69, 0x67, 0x62, 0x65, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x69, 0x67, 0x62, 0x65, + 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x69, 0x67, 0x62, 0x65, 0x6e, 0x20, + 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x42, 0x69, 0x67, 0x62, 0x65, 0x6e, 0x20, 0x50, + 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x20, 0x4d, 0x61, 0x72, + 0x73, 0x20, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x72, 0x6f, 0x6f, + 0x6b, 0x20, 0x4d, 0x61, 0x72, 0x73, 0x20, 0x50, 0x53, 0x34, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, + 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x66, 0x31, 0x30, 0x65, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, + 0x72, 0x6f, 0x6f, 0x6b, 0x20, 0x50, 0x53, 0x32, 0x20, 0x41, 0x64, 0x61, + 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x72, 0x6f, + 0x6f, 0x6b, 0x20, 0x53, 0x75, 0x70, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x6e, + 0x76, 0x65, 0x72, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, 0x31, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x75, 0x66, + 0x66, 0x61, 0x6c, 0x6f, 0x20, 0x42, 0x53, 0x47, 0x50, 0x31, 0x36, 0x30, + 0x31, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x2c, 0x61, 0x3a, 0x62, + 0x35, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x62, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x43, 0x61, 0x70, 0x63, 0x6f, 0x6d, 0x20, 0x48, 0x6f, 0x6d, + 0x65, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x33, + 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x62, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x43, 0x61, 0x70, 0x63, 0x6f, 0x6d, 0x20, 0x48, + 0x6f, 0x6d, 0x65, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x32, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, 0x68, 0x69, 0x6c, 0x6c, 0x53, + 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, + 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x35, 0x38, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x43, 0x69, 0x64, 0x65, 0x6b, 0x6f, 0x20, 0x41, 0x4b, 0x30, 0x38, 0x62, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x35, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x43, 0x6f, 0x62, 0x72, 0x61, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x33, 0x33, 0x36, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, + 0x6f, 0x6d, 0x70, 0x65, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, + 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, + 0x35, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x43, 0x72, 0x6f, 0x6e, 0x75, 0x73, 0x4d, 0x61, + 0x78, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x38, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x63, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x43, 0x74, 0x68, 0x75, 0x6c, 0x68, 0x75, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, + 0x38, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x63, 0x65, 0x66, 0x61, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x43, 0x74, 0x68, 0x75, 0x6c, 0x68, 0x75, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, + 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, + 0x79, 0x62, 0x65, 0x72, 0x20, 0x47, 0x61, 0x64, 0x67, 0x65, 0x74, 0x20, + 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x63, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, 0x79, 0x62, 0x6f, 0x72, + 0x67, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x32, 0x66, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, 0x79, 0x62, 0x6f, 0x72, 0x67, 0x20, + 0x56, 0x2e, 0x33, 0x20, 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x61, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x44, 0x41, 0x20, 0x4c, 0x65, 0x61, 0x64, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x37, 0x2c, 0x62, 0x3a, 0x62, 0x36, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x35, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x44, 0x61, 0x74, 0x65, 0x6c, 0x20, 0x41, + 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x35, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x44, 0x65, 0x66, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x47, 0x61, + 0x6d, 0x65, 0x20, 0x52, 0x61, 0x63, 0x65, 0x72, 0x20, 0x58, 0x37, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x39, 0x31, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x42, 0x6f, 0x78, 0x20, + 0x57, 0x69, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, + 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x65, 0x31, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x44, 0x75, 0x61, 0x6c, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x44, 0x75, 0x61, 0x6c, 0x20, + 0x50, 0x6f, 0x77, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x38, 0x2c, 0x62, + 0x3a, 0x62, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x62, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x44, 0x75, 0x61, + 0x6c, 0x20, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x20, 0x33, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x62, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x62, 0x64, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x56, 0x69, + 0x62, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x4a, 0x6f, 0x79, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x31, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x31, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x44, 0x75, 0x61, 0x6c, + 0x46, 0x6f, 0x72, 0x63, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x44, 0x75, 0x61, + 0x6c, 0x53, 0x68, 0x6f, 0x63, 0x6b, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x44, 0x75, 0x61, 0x6c, 0x53, 0x68, 0x6f, 0x63, 0x6b, 0x20, 0x33, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x41, 0x20, 0x53, 0x70, 0x6f, 0x72, + 0x74, 0x73, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x63, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x61, 0x73, 0x79, 0x20, + 0x47, 0x72, 0x69, 0x70, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x61, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, 0x6f, + 0x6d, 0x20, 0x44, 0x55, 0x58, 0x36, 0x30, 0x20, 0x4d, 0x4d, 0x4f, 0x2c, + 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x38, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, + 0x6f, 0x6d, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x62, 0x38, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, 0x6f, 0x6d, 0x20, 0x47, 0x61, 0x6d, + 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, + 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, + 0x6f, 0x6d, 0x20, 0x50, 0x33, 0x30, 0x31, 0x55, 0x20, 0x50, 0x6c, 0x61, + 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, + 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x31, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, 0x6f, + 0x6d, 0x20, 0x55, 0x31, 0x30, 0x31, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, + 0x6c, 0x65, 0x63, 0x6f, 0x6d, 0x20, 0x55, 0x33, 0x36, 0x31, 0x33, 0x4d, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, 0x6f, 0x6d, 0x20, 0x55, 0x33, 0x39, + 0x31, 0x32, 0x54, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, 0x6f, + 0x6d, 0x20, 0x55, 0x34, 0x30, 0x31, 0x33, 0x53, 0x2c, 0x61, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x45, 0x6c, 0x65, 0x63, 0x6f, 0x6d, 0x20, 0x55, 0x34, 0x31, 0x31, 0x33, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, 0x6f, 0x6d, 0x20, 0x55, 0x34, 0x31, + 0x31, 0x33, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, 0x6f, + 0x6d, 0x20, 0x57, 0x30, 0x31, 0x55, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x69, 0x6d, 0x69, 0x6e, 0x61, + 0x74, 0x6f, 0x72, 0x20, 0x41, 0x66, 0x74, 0x65, 0x72, 0x53, 0x68, 0x6f, + 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x2d, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, + 0x30, 0x30, 0x30, 0x30, 0x66, 0x36, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x69, + 0x74, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x45, 0x4d, 0x53, 0x20, 0x50, 0x72, 0x6f, 0x64, + 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x53, 0x32, 0x20, 0x41, + 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x62, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x53, 0x4d, 0x20, 0x39, 0x31, + 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x38, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x45, 0x73, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x61, + 0x6c, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x66, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x58, 0x45, 0x51, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x34, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x38, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x45, 0x58, 0x45, 0x51, 0x20, 0x52, 0x46, 0x20, 0x47, 0x61, 0x6d, + 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, + 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, + 0x61, 0x63, 0x65, 0x6f, 0x66, 0x66, 0x20, 0x44, 0x65, 0x6c, 0x75, 0x78, + 0x65, 0x20, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, + 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x61, 0x63, 0x65, 0x6f, 0x66, + 0x66, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, + 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x43, + 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x31, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x46, 0x43, 0x38, 0x30, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x35, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x46, 0x46, 0x20, 0x47, 0x50, 0x31, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, + 0x64, 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x66, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x46, 0x69, 0x67, 0x68, 0x74, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x65, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x69, 0x67, + 0x68, 0x74, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x38, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x69, 0x67, 0x68, 0x74, + 0x70, 0x61, 0x64, 0x20, 0x54, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x35, 0x30, + 0x33, 0x36, 0x38, 0x35, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x46, 0x61, 0x6e, + 0x74, 0x61, 0x73, 0x79, 0x20, 0x58, 0x49, 0x56, 0x20, 0x4f, 0x6e, 0x6c, + 0x69, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x61, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x69, 0x72, 0x65, 0x73, 0x74, + 0x6f, 0x72, 0x6d, 0x2c, 0x61, 0x3a, 0x62, 0x39, 0x2c, 0x62, 0x3a, 0x62, + 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x38, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x62, 0x35, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x46, 0x69, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, + 0x6d, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x35, 0x30, 0x37, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x69, 0x72, + 0x65, 0x73, 0x74, 0x6f, 0x72, 0x6d, 0x20, 0x44, 0x33, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x6c, 0x79, 0x64, + 0x69, 0x67, 0x69, 0x20, 0x41, 0x70, 0x65, 0x78, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x35, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x46, 0x6c, 0x79, 0x64, 0x69, 0x67, 0x69, 0x20, 0x56, 0x61, + 0x64, 0x65, 0x72, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x37, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, + 0x35, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x33, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x34, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x35, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x62, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x32, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x46, 0x6c, 0x79, 0x64, 0x69, 0x67, 0x69, 0x20, 0x56, 0x61, + 0x64, 0x65, 0x72, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x34, 0x2c, + 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x35, 0x2c, 0x70, + 0x61, 0x64, 0x64, 0x6c, 0x65, 0x33, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x70, + 0x61, 0x64, 0x64, 0x6c, 0x65, 0x34, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x32, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x6c, 0x79, 0x64, 0x69, + 0x67, 0x69, 0x20, 0x56, 0x61, 0x64, 0x65, 0x72, 0x20, 0x32, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, + 0x31, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, + 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, + 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x33, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x34, + 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x47, 0x30, 0x38, 0x58, 0x55, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x36, 0x66, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x20, 0x56, 0x49, 0x42, + 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x36, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x32, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, + 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x66, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, + 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x37, 0x31, 0x38, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, + 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, + 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, + 0x20, 0x33, 0x20, 0x54, 0x75, 0x72, 0x62, 0x6f, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x64, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, + 0x6d, 0x65, 0x53, 0x69, 0x72, 0x20, 0x47, 0x33, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x35, 0x62, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x20, 0x47, 0x33, + 0x77, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, 0x64, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x20, 0x47, + 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, + 0x69, 0x72, 0x20, 0x47, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x30, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, + 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x2d, 0x54, 0x33, 0x20, 0x32, 0x2e, + 0x30, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x65, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x73, 0x74, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x74, + 0x69, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x37, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x31, 0x36, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x74, 0x6f, 0x70, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x74, 0x6f, 0x70, + 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x75, 0x6e, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x36, 0x32, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, + 0x65, 0x74, 0x65, 0x6c, 0x20, 0x47, 0x54, 0x30, 0x30, 0x34, 0x20, 0x30, + 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x31, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x47, 0x61, 0x6d, 0x6f, 0x32, 0x20, 0x44, 0x69, 0x76, 0x61, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, + 0x30, 0x30, 0x61, 0x38, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x74, 0x6f, 0x72, + 0x20, 0x43, 0x6c, 0x61, 0x77, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x39, 0x31, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x43, 0x31, + 0x30, 0x30, 0x58, 0x46, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x65, 0x6e, 0x69, + 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x65, 0x6e, 0x69, 0x75, 0x73, + 0x20, 0x4d, 0x61, 0x78, 0x66, 0x69, 0x72, 0x65, 0x20, 0x42, 0x6c, 0x61, + 0x7a, 0x65, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x31, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x65, 0x6e, 0x69, + 0x75, 0x73, 0x20, 0x4d, 0x61, 0x78, 0x66, 0x69, 0x72, 0x65, 0x20, 0x47, + 0x72, 0x61, 0x6e, 0x64, 0x69, 0x61, 0x73, 0x20, 0x31, 0x32, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x63, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x33, 0x33, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x47, 0x65, 0x6e, 0x69, 0x75, 0x73, 0x20, 0x4d, 0x61, 0x78, + 0x46, 0x69, 0x72, 0x65, 0x20, 0x47, 0x72, 0x61, 0x6e, 0x64, 0x69, 0x61, + 0x73, 0x20, 0x31, 0x32, 0x56, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x47, 0x45, + 0x39, 0x30, 0x39, 0x20, 0x52, 0x65, 0x63, 0x6f, 0x69, 0x6c, 0x2c, 0x61, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x66, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x32, 0x38, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x47, 0x69, 0x6f, 0x74, 0x65, 0x63, 0x6b, 0x20, 0x50, 0x6c, + 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, 0x32, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x63, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x69, + 0x6f, 0x74, 0x65, 0x63, 0x6b, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, + 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x63, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x47, 0x69, 0x6f, 0x74, 0x65, 0x63, 0x6b, 0x20, 0x50, 0x53, 0x33, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x66, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x33, 0x38, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x47, 0x69, 0x6f, 0x74, 0x65, 0x63, 0x6b, 0x20, 0x56, 0x58, + 0x32, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, + 0x34, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x47, 0x69, 0x6f, 0x74, 0x65, 0x63, 0x6b, 0x20, + 0x56, 0x58, 0x32, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x36, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x50, 0x20, 0x58, 0x49, 0x44, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x34, 0x31, + 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x47, 0x50, 0x44, 0x20, 0x57, 0x69, 0x6e, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x62, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, + 0x50, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, 0x61, 0x76, 0x69, 0x73, 0x20, 0x44, + 0x65, 0x73, 0x74, 0x72, 0x6f, 0x79, 0x65, 0x72, 0x20, 0x54, 0x69, 0x6c, + 0x74, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, 0x61, 0x76, 0x69, 0x73, + 0x20, 0x45, 0x6c, 0x69, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x20, + 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, 0x61, 0x76, + 0x69, 0x73, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x64, 0x20, 0x50, + 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x2d, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, 0x65, 0x65, 0x6e, + 0x41, 0x73, 0x69, 0x61, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x62, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x54, 0x32, 0x61, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x61, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x61, 0x6d, 0x61, 0x20, 0x53, + 0x63, 0x6f, 0x72, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x61, 0x74, 0x73, + 0x75, 0x6e, 0x65, 0x20, 0x4d, 0x69, 0x6b, 0x75, 0x20, 0x53, 0x68, 0x6f, + 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x65, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x61, 0x76, 0x69, 0x74, 0x20, 0x48, + 0x56, 0x20, 0x47, 0x36, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, + 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x45, + 0x58, 0x54, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, 0x31, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x69, 0x74, 0x42, 0x6f, 0x78, + 0x20, 0x45, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x74, 0x68, + 0x75, 0x6c, 0x68, 0x75, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, + 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, + 0x4a, 0x44, 0x20, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, + 0x20, 0x44, 0x4f, 0x41, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, + 0x65, 0x72, 0x20, 0x32, 0x30, 0x31, 0x36, 0x20, 0x50, 0x53, 0x33, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, + 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, + 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, + 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, + 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x33, 0x20, 0x50, + 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, + 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x35, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, + 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, + 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x34, + 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, + 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, + 0x20, 0x34, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, + 0x65, 0x72, 0x20, 0x35, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, + 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, + 0x61, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, + 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, + 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, + 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x62, 0x61, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, + 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, + 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, + 0x69, 0x6e, 0x67, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x6d, 0x69, + 0x6e, 0x69, 0x20, 0x34, 0x20, 0x28, 0x50, 0x53, 0x33, 0x29, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, + 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, + 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x20, 0x34, 0x20, 0x28, 0x50, 0x53, 0x34, + 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, + 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x33, 0x57, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x20, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, + 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, + 0x45, 0x58, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, + 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x4d, + 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, + 0x66, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, + 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x56, 0x33, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x32, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x20, 0x56, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x47, 0x72, 0x69, 0x70, 0x20, + 0x54, 0x41, 0x43, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, + 0x30, 0x30, 0x30, 0x30, 0x61, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, + 0x69, 0x20, 0x4d, 0x69, 0x6b, 0x75, 0x20, 0x50, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x20, 0x44, 0x69, 0x76, 0x61, 0x20, 0x58, 0x20, 0x48, 0x44, + 0x20, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x61, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x4d, 0x69, + 0x6b, 0x75, 0x20, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x44, + 0x69, 0x76, 0x61, 0x20, 0x58, 0x20, 0x48, 0x44, 0x20, 0x50, 0x53, 0x34, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, 0x48, + 0x61, 0x74, 0x73, 0x75, 0x6e, 0x65, 0x20, 0x4d, 0x69, 0x6b, 0x75, 0x20, + 0x46, 0x54, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, + 0x61, 0x64, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, + 0x61, 0x64, 0x20, 0x33, 0x20, 0x54, 0x75, 0x72, 0x62, 0x6f, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x34, 0x64, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, 0x61, 0x64, 0x20, 0x41, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, 0x43, 0x20, 0x45, 0x6e, 0x67, 0x69, + 0x6e, 0x65, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, 0x6f, 0x6b, 0x6b, 0x65, 0x6e, + 0x20, 0x54, 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x6e, 0x74, 0x20, + 0x44, 0x58, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x32, 0x33, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, 0x53, 0x34, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x4c, + 0x69, 0x67, 0x68, 0x74, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, + 0x66, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, + 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, + 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, + 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, + 0x20, 0x50, 0x72, 0x6f, 0x20, 0x33, 0x50, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, + 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x34, 0x62, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, + 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, + 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x33, 0x57, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x36, 0x61, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, + 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x34, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, + 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x34, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x61, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, + 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x34, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x62, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, + 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x34, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, + 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x34, + 0x20, 0x56, 0x4c, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, + 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, + 0x20, 0x50, 0x72, 0x6f, 0x20, 0x34, 0x20, 0x56, 0x4c, 0x58, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, + 0x66, 0x30, 0x30, 0x30, 0x30, 0x33, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, + 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, + 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x4e, 0x33, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x61, 0x65, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, + 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x4e, 0x34, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, + 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, + 0x50, 0x72, 0x6f, 0x20, 0x50, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x61, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, + 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, + 0x20, 0x50, 0x72, 0x6f, 0x20, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, + 0x66, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, + 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, + 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x53, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, + 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, + 0x50, 0x72, 0x6f, 0x20, 0x56, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x35, 0x62, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, + 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, + 0x56, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, + 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, + 0x20, 0x56, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x61, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, + 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, + 0x6f, 0x20, 0x56, 0x48, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, + 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, + 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x56, 0x58, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x66, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, + 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, + 0x50, 0x72, 0x6f, 0x20, 0x56, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, + 0x54, 0x41, 0x43, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, + 0x30, 0x30, 0x30, 0x30, 0x63, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, + 0x69, 0x20, 0x54, 0x61, 0x69, 0x6b, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, + 0x66, 0x30, 0x30, 0x30, 0x30, 0x63, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, + 0x72, 0x69, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x70, + 0x61, 0x64, 0x20, 0x33, 0x54, 0x50, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, + 0x66, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, + 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x33, 0x57, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x48, 0x6f, 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x34, 0x20, 0x46, 0x50, + 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x34, + 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x70, 0x61, + 0x64, 0x20, 0x34, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, + 0x69, 0x70, 0x61, 0x64, 0x20, 0x41, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, + 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, + 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x45, 0x58, 0x54, 0x32, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x65, 0x65, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x4d, 0x69, + 0x6e, 0x69, 0x20, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x70, 0x61, + 0x64, 0x20, 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, + 0x70, 0x61, 0x64, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x34, 0x32, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x48, 0x79, 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x41, 0x64, 0x6d, + 0x69, 0x72, 0x61, 0x6c, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x2b, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x2b, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x2d, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x62, 0x38, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x34, 0x32, 0x65, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x62, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x48, 0x79, 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x4e, 0x36, 0x34, + 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x65, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x79, 0x70, + 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, + 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x65, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x61, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6b, 0x69, + 0x6e, 0x20, 0x54, 0x72, 0x6f, 0x6f, 0x70, 0x65, 0x72, 0x20, 0x32, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, 0x31, + 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x69, 0x42, + 0x75, 0x66, 0x66, 0x61, 0x6c, 0x6f, 0x20, 0x41, 0x43, 0x30, 0x32, 0x20, + 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, + 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, 0x31, 0x64, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x69, 0x42, 0x75, 0x66, 0x66, + 0x61, 0x6c, 0x6f, 0x20, 0x42, 0x53, 0x47, 0x50, 0x31, 0x32, 0x30, 0x34, + 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, + 0x31, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x69, + 0x42, 0x75, 0x66, 0x66, 0x61, 0x6c, 0x6f, 0x20, 0x42, 0x53, 0x47, 0x50, + 0x31, 0x32, 0x30, 0x34, 0x50, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x63, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x69, 0x44, 0x72, 0x6f, 0x69, 0x64, 0x43, 0x6f, + 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x36, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x39, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x36, 0x39, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x69, 0x44, 0x72, 0x6f, 0x69, 0x64, 0x43, 0x6f, 0x6e, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x62, 0x35, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x49, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x20, 0x42, 0x6c, 0x61, + 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x6a, 0x75, 0x73, + 0x74, 0x69, 0x63, 0x65, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x35, 0x31, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x20, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, + 0x66, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x49, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x20, 0x41, 0x78, 0x69, + 0x73, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, + 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, + 0x72, 0x41, 0x63, 0x74, 0x20, 0x41, 0x78, 0x69, 0x73, 0x50, 0x61, 0x64, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x61, 0x63, 0x74, + 0x20, 0x47, 0x6f, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, + 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x39, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, + 0x74, 0x20, 0x48, 0x61, 0x6d, 0x6d, 0x65, 0x72, 0x68, 0x65, 0x61, 0x64, + 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x61, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, + 0x74, 0x20, 0x48, 0x61, 0x6d, 0x6d, 0x65, 0x72, 0x68, 0x65, 0x61, 0x64, + 0x20, 0x46, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x3a, 0x62, + 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x66, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, + 0x20, 0x48, 0x61, 0x6d, 0x6d, 0x65, 0x72, 0x68, 0x65, 0x61, 0x64, 0x20, + 0x46, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x35, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x66, 0x64, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x35, 0x33, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x20, + 0x50, 0x72, 0x6f, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, + 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x63, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x49, 0x70, 0x65, 0x67, 0x61, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x39, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x49, 0x70, 0x65, 0x67, 0x61, 0x20, 0x50, 0x47, 0x39, 0x30, + 0x32, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x39, 0x31, 0x39, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x70, 0x65, 0x67, + 0x61, 0x20, 0x50, 0x47, 0x39, 0x30, 0x38, 0x37, 0x2c, 0x2b, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x2b, 0x61, 0x35, 0x2c, 0x2d, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, + 0x28, 0x4c, 0x29, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x6f, 0x79, + 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x52, 0x29, 0x2c, 0x2b, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x2b, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x2d, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x2d, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4a, 0x6f, 0x79, 0x70, 0x61, 0x64, 0x20, 0x41, 0x64, 0x61, + 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x64, 0x31, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x6f, 0x79, 0x70, + 0x61, 0x64, 0x20, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x20, 0x53, 0x68, 0x6f, + 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x31, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x30, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x50, 0x44, 0x20, 0x46, 0x46, + 0x42, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x59, 0x53, 0x20, 0x41, 0x64, + 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x59, 0x53, 0x20, 0x41, + 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, + 0x30, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x4b, 0x41, 0x44, 0x45, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x32, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4b, 0x65, 0x69, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x3a, + 0x62, 0x35, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4b, 0x69, 0x6e, 0x67, + 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x64, 0x31, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x65, 0x61, 0x64, 0x65, + 0x72, 0x73, 0x68, 0x69, 0x70, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, + 0x69, 0x63, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x63, 0x33, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x63, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x31, 0x63, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, + 0x63, 0x68, 0x20, 0x43, 0x68, 0x69, 0x6c, 0x6c, 0x53, 0x74, 0x72, 0x65, + 0x61, 0x6d, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x32, 0x63, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, + 0x63, 0x68, 0x20, 0x43, 0x6f, 0x72, 0x64, 0x6c, 0x65, 0x73, 0x73, 0x20, + 0x50, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x63, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, + 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x72, 0x64, + 0x6c, 0x65, 0x73, 0x73, 0x20, 0x57, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x6e, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x63, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x44, 0x75, + 0x61, 0x6c, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x64, 0x63, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, 0x33, + 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, + 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, 0x35, 0x31, 0x30, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x63, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, + 0x35, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x63, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, + 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, 0x37, 0x31, 0x30, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, + 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, + 0x46, 0x37, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x63, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, + 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x50, 0x72, 0x65, 0x63, + 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x63, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, + 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x57, 0x69, 0x6e, 0x67, 0x4d, + 0x61, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x62, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, + 0x63, 0x68, 0x20, 0x57, 0x69, 0x6e, 0x67, 0x4d, 0x61, 0x6e, 0x20, 0x41, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x7e, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x32, 0x7e, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x61, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, + 0x68, 0x20, 0x57, 0x69, 0x6e, 0x67, 0x4d, 0x61, 0x6e, 0x20, 0x52, 0x75, + 0x6d, 0x62, 0x6c, 0x65, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x79, 0x6e, + 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x32, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, + 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, + 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, 0x45, 0x20, 0x53, 0x20, 0x50, + 0x6c, 0x75, 0x73, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x35, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, + 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x46, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, 0x45, 0x20, 0x53, 0x20, + 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x35, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x43, 0x54, 0x52, + 0x4c, 0x52, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x36, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, + 0x74, 0x7a, 0x20, 0x43, 0x54, 0x52, 0x4c, 0x52, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, + 0x37, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, + 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, + 0x70, 0x61, 0x64, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, 0x53, 0x33, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x38, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, + 0x67, 0x68, 0x74, 0x70, 0x61, 0x64, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, + 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, + 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x20, + 0x41, 0x6c, 0x70, 0x68, 0x61, 0x20, 0x50, 0x53, 0x33, 0x09, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x62, + 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, 0x45, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, + 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, 0x45, 0x20, 0x53, 0x20, 0x50, 0x53, + 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, + 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, + 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, + 0x45, 0x20, 0x53, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, + 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, 0x45, 0x32, 0x20, 0x50, 0x53, 0x33, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, 0x45, + 0x32, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x32, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, + 0x61, 0x74, 0x7a, 0x20, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x20, 0x43, 0x54, + 0x52, 0x4c, 0x52, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x32, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, + 0x7a, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x42, 0x72, 0x61, 0x77, 0x6c, 0x70, 0x61, 0x64, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x37, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, + 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, + 0x61, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, + 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x38, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, + 0x20, 0x53, 0x46, 0x49, 0x56, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x30, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, + 0x7a, 0x20, 0x53, 0x46, 0x56, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, + 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, + 0x41, 0x6c, 0x70, 0x68, 0x61, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x38, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, + 0x74, 0x7a, 0x20, 0x53, 0x74, 0x72, 0x65, 0x65, 0x74, 0x20, 0x46, 0x69, + 0x67, 0x68, 0x74, 0x65, 0x72, 0x20, 0x34, 0x20, 0x58, 0x62, 0x6f, 0x78, + 0x20, 0x33, 0x36, 0x30, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x53, 0x74, + 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x54, 0x45, 0x32, + 0x20, 0x50, 0x53, 0x33, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x54, 0x45, 0x32, + 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x61, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4d, 0x61, 0x74, 0x72, 0x69, 0x63, 0x6f, 0x6d, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x62, 0x62, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, + 0x78, 0x4a, 0x6f, 0x79, 0x70, 0x61, 0x64, 0x20, 0x56, 0x69, 0x72, 0x74, + 0x75, 0x61, 0x6c, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x38, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x41, 0x72, + 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x35, 0x2c, 0x79, 0x3a, 0x62, 0x36, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, + 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, 0x30, 0x30, 0x33, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x46, 0x31, + 0x30, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, + 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x46, 0x33, 0x30, 0x30, 0x20, 0x41, + 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, + 0x68, 0x20, 0x46, 0x33, 0x30, 0x30, 0x20, 0x45, 0x6c, 0x69, 0x74, 0x65, + 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x34, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, + 0x6c, 0x61, 0x73, 0x68, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, + 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x31, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, + 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x47, 0x61, 0x6d, 0x65, + 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, 0x30, 0x30, 0x37, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x4d, + 0x61, 0x67, 0x69, 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x32, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, + 0x68, 0x20, 0x4d, 0x61, 0x67, 0x69, 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, + 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x61, 0x37, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x4d, 0x61, 0x67, + 0x69, 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x39, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, + 0x61, 0x73, 0x68, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x53, + 0x61, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x65, 0x38, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x57, + 0x69, 0x69, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x41, + 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, + 0x57, 0x69, 0x69, 0x20, 0x44, 0x6f, 0x6c, 0x70, 0x68, 0x69, 0x6e, 0x42, + 0x61, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, + 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x57, 0x69, 0x69, 0x20, + 0x55, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x34, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x65, 0x67, 0x61, 0x20, 0x44, 0x72, + 0x69, 0x76, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x61, 0x65, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x65, 0x67, 0x61, + 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x39, 0x39, 0x30, + 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4d, 0x65, 0x67, 0x61, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, + 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x44, 0x75, 0x61, 0x6c, + 0x20, 0x53, 0x74, 0x72, 0x69, 0x6b, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x33, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x7e, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, + 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, + 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, + 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, + 0x73, 0x6f, 0x66, 0x74, 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, + 0x64, 0x65, 0x72, 0x20, 0x46, 0x72, 0x65, 0x65, 0x73, 0x74, 0x79, 0x6c, + 0x65, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, + 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x20, 0x50, 0x6c, 0x75, 0x67, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x6c, + 0x6c, 0x65, 0x72, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x43, 0x61, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x33, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x4c, 0x47, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, + 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, 0x33, 0x65, 0x66, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, + 0x4c, 0x47, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x20, 0x54, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x39, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x38, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4d, 0x4c, 0x47, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x6f, 0x63, + 0x75, 0x74, 0x65, 0x20, 0x4d, 0x30, 0x35, 0x33, 0x2c, 0x61, 0x3a, 0x62, + 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, + 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, + 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x35, 0x38, 0x39, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4d, 0x6f, 0x67, 0x61, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x31, 0x36, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4d, 0x6f, 0x67, 0x61, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, + 0x64, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x6f, 0x67, 0x61, 0x20, 0x50, 0x72, 0x6f, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x61, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x6f, 0x67, 0x61, 0x20, + 0x58, 0x50, 0x35, 0x41, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x62, 0x38, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4d, 0x6f, 0x67, 0x61, 0x20, 0x58, 0x50, 0x35, 0x41, 0x20, 0x50, + 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x61, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x6f, 0x67, 0x61, 0x20, + 0x58, 0x50, 0x35, 0x58, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x62, 0x38, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4d, 0x6f, 0x67, 0x61, 0x20, 0x58, 0x50, 0x35, 0x58, 0x20, 0x50, + 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x36, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x50, 0x2d, 0x38, 0x38, + 0x36, 0x36, 0x20, 0x53, 0x75, 0x70, 0x65, 0x72, 0x20, 0x44, 0x75, 0x61, + 0x6c, 0x20, 0x42, 0x6f, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x31, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x55, 0x53, + 0x49, 0x41, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x32, 0x20, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x44, + 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x31, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x37, 0x30, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x36, + 0x34, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x69, 0x64, 0x2c, 0x2b, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x2b, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x2d, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x2d, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x62, 0x35, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x61, 0x63, 0x6f, 0x6e, + 0x20, 0x47, 0x43, 0x20, 0x34, 0x30, 0x30, 0x45, 0x53, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, + 0x61, 0x63, 0x6f, 0x6e, 0x20, 0x52, 0x65, 0x76, 0x6f, 0x6c, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x20, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x62, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4e, 0x61, 0x63, 0x6f, 0x6e, 0x20, 0x52, 0x65, 0x76, 0x6f, 0x6c, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x49, 0x6e, 0x66, 0x69, 0x6e, 0x69, 0x74, + 0x79, 0x20, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x61, 0x63, 0x6f, + 0x6e, 0x20, 0x52, 0x65, 0x76, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x55, 0x6e, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x20, 0x50, + 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x62, 0x64, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x65, 0x62, 0x75, 0x6c, 0x61, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x65, 0x62, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x65, 0x47, 0x63, 0x6f, 0x6e, 0x20, 0x41, + 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x61, 0x32, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, + 0x37, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x65, 0x66, 0x62, + 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4e, 0x45, 0x4f, 0x20, 0x53, 0x45, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x31, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x34, 0x37, 0x34, 0x65, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x65, + 0x6f, 0x47, 0x65, 0x6f, 0x20, 0x58, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, + 0x65, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x32, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x34, 0x62, 0x34, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4e, 0x45, 0x53, 0x20, 0x32, 0x20, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x41, + 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x31, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x33, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x45, 0x53, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x31, 0x38, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4e, 0x45, 0x58, 0x49, 0x4c, 0x55, 0x58, 0x20, 0x47, 0x61, 0x6d, + 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, + 0x45, 0x58, 0x54, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x65, 0x78, + 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x47, 0x44, 0x53, 0x2c, 0x61, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, + 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x6f, 0x73, 0x74, 0x72, + 0x6f, 0x6d, 0x6f, 0x20, 0x4e, 0x34, 0x35, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x53, 0x4f, + 0x20, 0x4e, 0x36, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x62, 0x38, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, + 0x32, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x37, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, + 0x31, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x53, 0x4f, 0x20, 0x53, 0x4e, 0x45, + 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, + 0x39, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x37, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x56, + 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x39, 0x2c, 0x79, 0x3a, 0x62, + 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, + 0x20, 0x53, 0x68, 0x69, 0x65, 0x6c, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x39, + 0x2c, 0x62, 0x3a, 0x62, 0x38, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x37, + 0x2c, 0x79, 0x3a, 0x62, 0x36, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, + 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x56, + 0x49, 0x44, 0x49, 0x41, 0x20, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2d, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x79, 0x6b, 0x6f, 0x20, 0x41, 0x69, 0x72, + 0x20, 0x46, 0x6c, 0x6f, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x62, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4e, 0x79, 0x6b, 0x6f, 0x20, 0x41, 0x69, 0x72, 0x66, 0x6c, 0x6f, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x64, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x79, 0x6b, + 0x6f, 0x20, 0x41, 0x69, 0x72, 0x66, 0x6c, 0x6f, 0x20, 0x50, 0x53, 0x33, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x39, 0x31, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4e, 0x79, 0x6b, 0x6f, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x70, 0x61, + 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x38, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4f, 0x6e, 0x6c, 0x69, 0x76, 0x65, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4f, 0x6e, 0x79, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x39, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4f, 0x6e, 0x7a, 0x61, 0x20, 0x43, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4f, 0x6e, 0x7a, + 0x61, 0x20, 0x54, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x64, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4f, 0x50, 0x50, 0x20, 0x50, 0x53, + 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x32, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4f, 0x55, 0x59, 0x41, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x38, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x78, 0x3a, + 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x66, 0x36, 0x30, 0x65, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x50, 0x34, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x43, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, + 0x65, 0x30, 0x30, 0x30, 0x30, 0x38, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, + 0x50, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x70, 0x61, 0x64, 0x20, 0x50, + 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, + 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, 0x20, 0x50, 0x53, + 0x33, 0x20, 0x56, 0x65, 0x72, 0x73, 0x75, 0x73, 0x20, 0x46, 0x69, 0x67, + 0x68, 0x74, 0x69, 0x6e, 0x67, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x50, 0x6c, 0x61, 0x79, 0x53, 0x65, 0x67, 0x61, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x37, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, + 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x64, 0x61, 0x30, 0x63, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, + 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, + 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x32, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6c, + 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x66, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x31, 0x38, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x39, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, + 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x37, 0x31, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x56, 0x69, 0x74, 0x61, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x64, 0x63, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x41, 0x20, 0x50, + 0x72, 0x6f, 0x20, 0x45, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x30, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x64, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, 0x72, + 0x41, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x33, 0x61, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x41, + 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x34, 0x63, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x72, 0x65, 0x63, + 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x35, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x72, 0x6f, + 0x20, 0x45, 0x6c, 0x69, 0x74, 0x65, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x35, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, + 0x72, 0x6f, 0x20, 0x45, 0x78, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x66, 0x33, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x50, 0x72, 0x6f, 0x20, 0x45, 0x78, 0x20, 0x6d, 0x69, 0x6e, + 0x69, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x37, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x72, 0x6f, 0x20, 0x45, 0x78, + 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, + 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x65, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x72, + 0x6f, 0x35, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x31, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x37, 0x35, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x50, 0x53, 0x31, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, + 0x53, 0x32, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x32, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, + 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x38, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, + 0x53, 0x32, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x38, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x32, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, + 0x53, 0x32, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x64, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x50, 0x53, 0x32, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x61, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x32, + 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x20, 0x41, + 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x61, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, + 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x63, 0x66, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x66, 0x39, 0x30, + 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, + 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x7e, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x31, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x37, 0x35, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x38, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x79, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, + 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x61, 0x32, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x37, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x31, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x31, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x33, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x38, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x39, 0x31, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, + 0x30, 0x30, 0x61, 0x39, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x61, 0x61, 0x35, 0x37, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, + 0x30, 0x30, 0x66, 0x32, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x66, 0x33, 0x31, 0x63, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, + 0x30, 0x30, 0x66, 0x34, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x66, 0x35, 0x31, 0x63, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, + 0x30, 0x30, 0x66, 0x37, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x32, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, 0x65, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x61, 0x31, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x61, 0x30, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x34, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, + 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x74, 0x6f, 0x75, 0x63, 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, + 0x63, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x65, 0x36, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x74, 0x6f, 0x75, 0x63, + 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x66, 0x32, 0x30, 0x64, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, + 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, + 0x31, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x74, + 0x6f, 0x75, 0x63, 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x50, 0x53, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, + 0x62, 0x61, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, 0x62, + 0x61, 0x20, 0x32, 0x50, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, 0x62, + 0x61, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, 0x74, 0x69, + 0x63, 0x6b, 0x20, 0x31, 0x30, 0x30, 0x38, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, + 0x61, 0x6e, 0x62, 0x61, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, + 0x53, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x34, 0x30, 0x31, 0x38, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, 0x63, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, 0x62, 0x61, 0x20, 0x44, + 0x72, 0x61, 0x67, 0x6f, 0x6e, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, + 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, + 0x32, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, + 0x61, 0x6e, 0x62, 0x61, 0x20, 0x44, 0x72, 0x6f, 0x6e, 0x65, 0x20, 0x41, + 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x32, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, 0x62, 0x61, 0x20, + 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x51, 0x61, 0x6e, 0x62, 0x61, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x34, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x51, 0x61, 0x6e, 0x62, 0x61, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x20, 0x51, 0x34, 0x52, 0x41, 0x46, 0x2c, 0x61, 0x3a, + 0x62, 0x35, 0x2c, 0x62, 0x3a, 0x62, 0x36, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, + 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, + 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, + 0x6e, 0x62, 0x61, 0x20, 0x4f, 0x62, 0x73, 0x69, 0x64, 0x69, 0x61, 0x6e, + 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, 0x74, 0x69, 0x63, + 0x6b, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, 0x63, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, 0x62, 0x61, + 0x20, 0x4f, 0x62, 0x73, 0x69, 0x64, 0x69, 0x61, 0x6e, 0x20, 0x41, 0x72, + 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x50, + 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x61, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x36, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x31, 0x20, 0x4d, 0x6f, 0x62, 0x69, + 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x32, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x52, 0x61, 0x64, 0x69, 0x6f, 0x53, 0x68, 0x61, 0x63, 0x6b, 0x2c, + 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x66, 0x66, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x34, 0x37, + 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x52, 0x61, 0x6d, 0x6f, 0x78, 0x20, 0x46, 0x50, 0x53, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, + 0x33, 0x44, 0x4f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x36, 0x39, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x33, 0x44, 0x4f, 0x20, + 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, + 0x6e, 0x65, 0x74, 0x20, 0x44, 0x72, 0x65, 0x61, 0x6d, 0x63, 0x61, 0x73, + 0x74, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x35, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x47, 0x43, 0x20, + 0x61, 0x6e, 0x64, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x41, 0x64, 0x61, 0x70, + 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x2b, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, + 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x47, 0x43, 0x20, 0x61, + 0x6e, 0x64, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x37, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x2b, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, + 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, + 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, + 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x4a, 0x61, 0x67, 0x75, 0x61, + 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, + 0x78, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, + 0x4e, 0x45, 0x53, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x37, 0x2c, 0x62, 0x3a, 0x62, 0x36, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x50, 0x53, 0x31, 0x20, + 0x61, 0x6e, 0x64, 0x20, 0x50, 0x53, 0x32, 0x20, 0x41, 0x64, 0x61, 0x70, + 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x35, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x34, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x53, + 0x61, 0x74, 0x75, 0x72, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, + 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, + 0x6e, 0x65, 0x74, 0x20, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x41, + 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20, 0x32, 0x2e, 0x30, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, + 0x65, 0x74, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x41, 0x64, 0x61, 0x70, + 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, + 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, + 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, + 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, + 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x35, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, + 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, + 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, + 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, + 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x56, 0x65, 0x63, 0x74, 0x72, + 0x65, 0x78, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, + 0x57, 0x69, 0x69, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, + 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x32, 0x63, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x57, 0x69, 0x69, 0x20, + 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x41, 0x64, 0x61, 0x70, + 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, + 0x6e, 0x65, 0x74, 0x20, 0x57, 0x69, 0x69, 0x20, 0x43, 0x6c, 0x61, 0x73, + 0x73, 0x69, 0x63, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x35, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x48, 0x79, + 0x64, 0x72, 0x61, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x66, 0x38, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x62, 0x66, 0x30, + 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x4b, 0x69, 0x73, 0x68, + 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x36, 0x2c, 0x62, 0x3a, 0x62, 0x37, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x39, 0x2c, + 0x79, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, + 0x7a, 0x65, 0x72, 0x20, 0x50, 0x61, 0x6e, 0x74, 0x68, 0x65, 0x72, 0x61, + 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x50, + 0x61, 0x6e, 0x74, 0x68, 0x65, 0x72, 0x61, 0x20, 0x50, 0x53, 0x34, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, 0x69, 0x6a, 0x75, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, + 0x69, 0x6a, 0x75, 0x20, 0x4d, 0x6f, 0x62, 0x69, 0x6c, 0x65, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, + 0x69, 0x6a, 0x75, 0x20, 0x4d, 0x6f, 0x62, 0x69, 0x6c, 0x65, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, + 0x69, 0x6a, 0x75, 0x20, 0x54, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, + 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, 0x69, 0x6a, 0x75, 0x20, 0x54, 0x45, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, + 0x69, 0x6a, 0x75, 0x20, 0x55, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, + 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, 0x69, 0x6a, 0x75, 0x20, 0x55, 0x45, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, + 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x69, 0x67, 0x68, + 0x74, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, + 0x53, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x2b, 0x61, 0x32, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x32, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x34, 0x37, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x20, 0x42, 0x69, 0x74, 0x20, 0x53, + 0x65, 0x67, 0x61, 0x20, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, + 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, + 0x65, 0x74, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, + 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x62, 0x64, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x33, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x6c, 0x69, + 0x6e, 0x6b, 0x20, 0x53, 0x65, 0x67, 0x61, 0x20, 0x53, 0x61, 0x74, 0x75, + 0x72, 0x6e, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, + 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x64, 0x31, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x35, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x6c, + 0x69, 0x6e, 0x6b, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x55, 0x53, + 0x42, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x50, + 0x6f, 0x72, 0x74, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x62, 0x38, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, + 0x39, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x37, 0x2c, 0x62, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x52, 0x65, 0x74, 0x72, 0x6f, 0x55, 0x53, 0x42, 0x20, 0x52, 0x65, 0x74, + 0x72, 0x6f, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x35, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x55, 0x53, 0x42, 0x20, + 0x53, 0x75, 0x70, 0x65, 0x72, 0x20, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x50, + 0x6f, 0x72, 0x74, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x35, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x52, 0x65, 0x76, 0x65, 0x6e, 0x67, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, + 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x76, 0x6f, + 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x64, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, + 0x65, 0x76, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x72, + 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x33, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x76, 0x6f, 0x6c, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, 0x63, + 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, 0x63, + 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x66, 0x65, 0x66, 0x61, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, 0x63, + 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x65, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, 0x63, 0x6b, 0x20, 0x43, + 0x61, 0x6e, 0x64, 0x79, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, 0x63, + 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, 0x50, 0x53, 0x33, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x32, 0x66, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x52, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, 0x50, + 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x38, 0x37, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x52, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, + 0x79, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x65, 0x33, 0x31, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, + 0x4f, 0x47, 0x20, 0x43, 0x68, 0x61, 0x6b, 0x72, 0x61, 0x6d, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, + 0x65, 0x35, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x4f, 0x47, 0x20, 0x43, 0x68, 0x61, + 0x6b, 0x72, 0x61, 0x6d, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x31, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, + 0x4f, 0x47, 0x20, 0x43, 0x68, 0x61, 0x6b, 0x72, 0x61, 0x6d, 0x20, 0x43, + 0x6f, 0x72, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x62, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, 0x61, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x4f, + 0x47, 0x20, 0x43, 0x68, 0x61, 0x6b, 0x72, 0x61, 0x6d, 0x20, 0x58, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x61, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x4f, 0x47, 0x20, 0x43, 0x68, + 0x61, 0x6b, 0x72, 0x61, 0x6d, 0x20, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x31, 0x63, 0x31, + 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x52, 0x4f, 0x47, 0x20, 0x43, 0x68, 0x61, 0x6b, 0x72, 0x61, + 0x6d, 0x20, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x64, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x75, + 0x6d, 0x62, 0x6c, 0x65, 0x20, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x39, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, + 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x53, 0x61, 0x62, 0x65, 0x72, 0x74, 0x6f, 0x6f, 0x74, 0x68, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, + 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x53, 0x61, 0x62, 0x65, 0x72, 0x74, 0x6f, 0x6f, 0x74, 0x68, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x66, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x43, 0x79, 0x62, + 0x6f, 0x72, 0x67, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x33, 0x66, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, + 0x6b, 0x20, 0x43, 0x79, 0x62, 0x6f, 0x72, 0x67, 0x20, 0x56, 0x2e, 0x31, + 0x20, 0x47, 0x61, 0x6d, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, + 0x6b, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x41, 0x6e, 0x61, 0x6c, 0x6f, + 0x67, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, + 0x50, 0x32, 0x32, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, + 0x62, 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, + 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, + 0x32, 0x35, 0x30, 0x30, 0x20, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x20, 0x52, + 0x75, 0x6d, 0x62, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x35, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, + 0x74, 0x65, 0x6b, 0x20, 0x50, 0x32, 0x36, 0x30, 0x30, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x64, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, + 0x65, 0x6b, 0x20, 0x50, 0x32, 0x36, 0x30, 0x30, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, + 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x32, 0x39, 0x30, 0x30, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x66, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x33, 0x32, + 0x30, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, + 0x20, 0x50, 0x34, 0x38, 0x30, 0x20, 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, + 0x38, 0x38, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, + 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x39, 0x39, 0x30, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x53, 0x31, 0x30, + 0x30, 0x30, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x66, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x53, + 0x32, 0x37, 0x30, 0x30, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, + 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x38, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, + 0x61, 0x6d, 0x73, 0x75, 0x6e, 0x67, 0x20, 0x45, 0x49, 0x47, 0x50, 0x32, + 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x6e, 0x77, 0x61, + 0x20, 0x45, 0x61, 0x73, 0x79, 0x20, 0x47, 0x72, 0x69, 0x70, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x53, 0x61, 0x6e, 0x77, 0x61, 0x20, 0x4d, 0x69, 0x63, 0x72, 0x6f, + 0x20, 0x47, 0x72, 0x69, 0x70, 0x20, 0x50, 0x33, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x31, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x53, 0x61, 0x6e, 0x77, 0x61, 0x20, 0x4d, 0x69, 0x63, + 0x72, 0x6f, 0x20, 0x47, 0x72, 0x69, 0x70, 0x20, 0x50, 0x72, 0x6f, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x53, 0x61, 0x6e, 0x77, 0x61, 0x20, 0x4d, 0x69, 0x63, + 0x72, 0x6f, 0x20, 0x47, 0x72, 0x69, 0x70, 0x20, 0x50, 0x72, 0x6f, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x53, 0x61, 0x6e, 0x77, 0x61, 0x20, 0x4f, 0x6e, 0x6c, + 0x69, 0x6e, 0x65, 0x20, 0x47, 0x72, 0x69, 0x70, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x33, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x53, 0x61, 0x6e, 0x77, 0x61, 0x20, 0x50, 0x6c, 0x61, 0x79, + 0x4f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x4d, 0x6f, 0x62, 0x69, 0x6c, + 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, + 0x61, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x6e, 0x77, 0x61, 0x20, 0x53, 0x6d, + 0x61, 0x72, 0x74, 0x20, 0x47, 0x72, 0x69, 0x70, 0x20, 0x49, 0x49, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x31, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x74, + 0x65, 0x63, 0x68, 0x69, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x63, 0x6f, + 0x72, 0x65, 0x20, 0x41, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x35, 0x32, 0x65, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x35, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x63, 0x75, 0x66, + 0x20, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, + 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x20, 0x4d, 0x69, 0x6e, 0x69, + 0x20, 0x33, 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, 0x4d, 0x65, 0x67, 0x61, 0x20, 0x44, + 0x72, 0x69, 0x76, 0x65, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, 0x36, 0x42, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x39, 0x62, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, + 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, 0x53, 0x61, + 0x74, 0x75, 0x72, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x35, 0x2c, 0x79, 0x3a, 0x62, 0x36, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x33, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, 0x53, 0x61, + 0x74, 0x75, 0x72, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x65, + 0x67, 0x61, 0x20, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x62, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x46, 0x58, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, + 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, + 0x38, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x53, 0x68, 0x6f, 0x67, 0x75, 0x6e, 0x20, 0x42, 0x72, 0x6f, 0x73, 0x20, + 0x43, 0x68, 0x61, 0x6d, 0x65, 0x6c, 0x65, 0x6f, 0x6e, 0x20, 0x58, 0x31, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, + 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x63, 0x31, 0x65, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, + 0x6e, 0x61, 0x6b, 0x65, 0x42, 0x79, 0x74, 0x65, 0x20, 0x34, 0x53, 0x20, + 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, + 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, + 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x36, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x4e, 0x45, 0x53, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x35, 0x2c, 0x79, + 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x37, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x64, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x4e, 0x45, 0x53, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, + 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x62, 0x32, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x4e, 0x45, 0x53, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, + 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x31, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x36, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, + 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, + 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x62, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x6f, 0x6e, 0x79, 0x20, + 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x50, 0x6f, 0x72, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x53, 0x70, 0x65, 0x65, 0x64, 0x6c, 0x69, 0x6e, + 0x6b, 0x20, 0x36, 0x35, 0x35, 0x35, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x61, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x70, 0x65, + 0x65, 0x64, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x36, 0x35, 0x36, 0x36, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, + 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x53, 0x70, 0x65, 0x65, 0x64, 0x6c, 0x69, 0x6e, 0x6b, + 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x65, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, + 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x53, 0x70, 0x65, 0x65, 0x64, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x53, 0x74, + 0x72, 0x69, 0x6b, 0x65, 0x20, 0x46, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, + 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x39, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, + 0x70, 0x65, 0x65, 0x64, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x54, 0x6f, 0x72, + 0x69, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x31, 0x31, 0x38, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x61, 0x64, 0x69, 0x61, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x66, 0x63, 0x31, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, 0x56, 0x69, 0x72, 0x74, 0x75, + 0x61, 0x6c, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x31, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, 0x56, 0x69, 0x72, 0x74, 0x75, + 0x61, 0x6c, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x2d, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, + 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x20, 0x50, 0x6c, 0x61, 0x79, + 0x20, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x74, 0x65, 0x63, 0x68, 0x20, 0x50, + 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x39, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, + 0x72, 0x69, 0x65, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x32, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, + 0x69, 0x65, 0x73, 0x20, 0x46, 0x72, 0x65, 0x65, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x31, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, + 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, 0x74, 0x75, 0x73, 0x20, 0x44, 0x75, + 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, + 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, 0x74, + 0x75, 0x73, 0x20, 0x44, 0x75, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x31, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, + 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, 0x74, 0x75, + 0x73, 0x20, 0x44, 0x75, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x38, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, + 0x72, 0x69, 0x65, 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, 0x74, 0x75, 0x73, + 0x20, 0x58, 0x4c, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x63, 0x31, + 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x53, 0x54, 0x4b, 0x20, 0x37, 0x30, 0x32, 0x34, 0x58, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x38, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x72, 0x65, 0x65, 0x74, 0x20, + 0x46, 0x69, 0x67, 0x68, 0x74, 0x65, 0x72, 0x20, 0x46, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, 0x45, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x66, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x53, 0x75, 0x70, 0x65, 0x72, 0x20, 0x46, 0x61, 0x6d, 0x69, + 0x63, 0x6f, 0x6d, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, + 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x38, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x53, 0x75, 0x70, 0x65, 0x72, 0x20, 0x46, 0x61, 0x6d, 0x69, 0x63, 0x6f, + 0x6d, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x34, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x53, 0x75, 0x70, 0x65, 0x72, 0x20, 0x52, 0x61, 0x63, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x61, 0x37, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x77, 0x69, + 0x74, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x66, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x48, + 0x6f, 0x72, 0x69, 0x20, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, + 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x31, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, + 0x7a, 0x6d, 0x79, 0x20, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x20, 0x50, 0x43, + 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x62, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x4d, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x41, 0x43, 0x20, + 0x47, 0x45, 0x41, 0x52, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x34, 0x30, 0x61, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x61, 0x69, 0x74, + 0x6f, 0x20, 0x45, 0x67, 0x72, 0x65, 0x74, 0x20, 0x49, 0x49, 0x20, 0x4d, + 0x69, 0x6e, 0x69, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x2d, 0x61, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x38, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x45, 0x20, + 0x4b, 0x69, 0x74, 0x74, 0x79, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x61, 0x31, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x65, 0x61, + 0x6d, 0x20, 0x35, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x35, 0x30, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x32, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x65, 0x63, 0x68, 0x6d, + 0x6f, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x20, 0x58, 0x36, 0x2d, 0x33, + 0x38, 0x56, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x61, 0x32, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x65, 0x63, 0x68, 0x6e, 0x6f, + 0x6c, 0x6f, 0x67, 0x79, 0x20, 0x49, 0x6e, 0x6e, 0x6f, 0x76, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x53, 0x32, 0x20, 0x41, 0x64, 0x61, 0x70, + 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x31, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x65, 0x6e, 0x63, 0x65, + 0x6e, 0x74, 0x20, 0x58, 0x69, 0x61, 0x6e, 0x79, 0x6f, 0x75, 0x20, 0x47, + 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x47, 0x5a, 0x2c, 0x61, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x39, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x54, 0x48, 0x45, 0x43, 0x36, 0x34, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x39, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x54, 0x48, 0x45, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x62, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, + 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x44, + 0x75, 0x61, 0x6c, 0x20, 0x41, 0x6e, 0x61, 0x6c, 0x6f, 0x67, 0x20, 0x34, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x33, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, + 0x73, 0x74, 0x65, 0x72, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x54, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x65, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, + 0x73, 0x74, 0x4d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x65, 0x53, 0x77, + 0x61, 0x70, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, + 0x74, 0x4d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x46, 0x65, 0x72, 0x72, + 0x61, 0x72, 0x69, 0x20, 0x31, 0x35, 0x30, 0x20, 0x50, 0x6c, 0x61, 0x79, + 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, + 0x74, 0x65, 0x72, 0x20, 0x46, 0x69, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, + 0x6d, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x50, 0x6f, 0x77, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x62, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, + 0x65, 0x72, 0x20, 0x46, 0x69, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x6d, + 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x4d, 0x61, 0x73, + 0x74, 0x65, 0x72, 0x20, 0x52, 0x75, 0x6e, 0x20, 0x4e, 0x20, 0x44, 0x72, + 0x69, 0x76, 0x65, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x4d, 0x61, 0x73, + 0x74, 0x65, 0x72, 0x20, 0x52, 0x75, 0x6e, 0x20, 0x4e, 0x20, 0x44, 0x72, + 0x69, 0x76, 0x65, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x38, 0x63, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x75, 0x6e, 0x64, 0x65, + 0x72, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x36, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x69, 0x67, 0x65, + 0x72, 0x47, 0x61, 0x6d, 0x65, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x36, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x38, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x54, 0x69, 0x67, 0x65, 0x72, 0x47, 0x61, 0x6d, 0x65, 0x20, 0x50, + 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x41, + 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x4d, 0x69, 0x6e, 0x69, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x37, 0x31, 0x64, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x54, 0x6f, 0x6d, 0x65, 0x65, 0x20, 0x4e, 0x45, 0x53, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, + 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x37, 0x31, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x6f, 0x6d, 0x65, + 0x65, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, + 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, + 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x50, 0x53, + 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x54, 0x72, 0x6f, 0x6e, 0x73, 0x6d, 0x61, 0x72, 0x74, 0x2c, + 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x66, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x63, 0x35, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x54, 0x72, 0x75, 0x73, 0x74, 0x20, 0x47, 0x61, 0x6d, + 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x38, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x72, 0x75, 0x73, 0x74, 0x20, + 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x37, 0x62, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x57, 0x43, + 0x53, 0x20, 0x54, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x2d, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x2b, 0x61, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x31, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x77, + 0x69, 0x6e, 0x20, 0x53, 0x68, 0x6f, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, + 0x39, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x54, 0x77, 0x69, 0x6e, 0x53, 0x68, 0x6f, 0x63, 0x6b, 0x20, 0x50, 0x53, + 0x32, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x36, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x55, 0x6e, 0x69, 0x70, 0x6c, 0x61, 0x79, 0x20, + 0x55, 0x36, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x63, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x37, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x75, 0x52, 0x61, 0x67, + 0x65, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x62, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x55, 0x53, 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x53, 0x42, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, + 0x53, 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x33, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x53, 0x42, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x36, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x53, 0x42, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x55, 0x53, 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x53, 0x42, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x62, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x63, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x55, 0x53, 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x35, 0x30, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x35, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x53, 0x42, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x62, 0x64, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x55, 0x53, 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, + 0x66, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x33, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x55, 0x53, 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x53, 0x42, 0x20, 0x56, 0x69, + 0x62, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x4a, 0x6f, 0x79, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x61, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x56, 0x65, 0x6e, 0x6f, + 0x6d, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x62, + 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x56, 0x65, 0x6e, 0x6f, 0x6d, 0x20, 0x41, 0x72, 0x63, + 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x56, 0x69, 0x63, 0x74, 0x72, + 0x69, 0x78, 0x20, 0x50, 0x53, 0x34, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x46, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x56, 0x69, 0x63, 0x74, 0x72, 0x69, 0x78, 0x20, + 0x50, 0x53, 0x34, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x46, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x34, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, + 0x62, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x76, 0x4a, 0x6f, 0x79, 0x20, 0x44, 0x65, 0x76, 0x69, + 0x63, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x35, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x34, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x61, 0x62, 0x35, 0x37, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x57, 0x61, 0x72, 0x72, 0x69, 0x6f, 0x72, 0x20, 0x4a, 0x6f, 0x79, 0x70, + 0x61, 0x64, 0x20, 0x4a, 0x53, 0x30, 0x38, 0x33, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, + 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x57, 0x69, 0x69, 0x20, 0x55, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, + 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, + 0x36, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x57, 0x69, 0x6c, + 0x64, 0x63, 0x61, 0x74, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x34, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x57, 0x6f, 0x6c, 0x76, 0x65, 0x72, + 0x69, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x65, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x65, 0x66, 0x62, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, + 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, + 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x34, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, + 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x36, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, + 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x36, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, + 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x36, 0x62, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, + 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x34, + 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x30, 0x37, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2d, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, + 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, + 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x66, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, + 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x66, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, + 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, + 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x66, 0x64, 0x66, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, + 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, + 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x70, + 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x61, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, + 0x57, 0x69, 0x72, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x52, 0x65, 0x63, + 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2d, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, + 0x78, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x69, 0x76, 0x65, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x2d, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x38, 0x38, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, + 0x7e, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x61, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x39, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x38, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, + 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x36, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, + 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x34, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x36, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x35, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x37, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, + 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, + 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x64, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x64, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, + 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, + 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x65, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, + 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x33, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x61, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2d, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x66, 0x66, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, + 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x2b, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2d, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, + 0x30, 0x61, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, + 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x33, 0x61, 0x35, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x61, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x65, 0x6f, 0x78, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x35, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x58, 0x65, 0x6f, 0x78, 0x20, 0x53, 0x4c, 0x36, 0x35, 0x35, + 0x36, 0x42, 0x4b, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x47, 0x65, 0x61, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x37, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x34, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x58, 0x69, 0x61, 0x6f, 0x6d, 0x69, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x37, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x33, 0x33, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x58, 0x69, 0x61, 0x6f, 0x6d, 0x69, 0x20, 0x58, 0x4d, 0x47, 0x50, + 0x30, 0x31, 0x59, 0x4d, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x62, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x58, 0x69, 0x61, 0x6f, 0x6d, 0x69, 0x20, 0x58, 0x4d, 0x47, 0x50, + 0x30, 0x31, 0x59, 0x4d, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x2b, 0x61, 0x32, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x2b, 0x61, 0x35, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x2d, + 0x61, 0x31, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x2d, + 0x61, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, + 0x0d, 0x0a, 0x78, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x2c, 0x58, 0x49, 0x6e, + 0x70, 0x75, 0x74, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x58, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x6f, + 0x72, 0x20, 0x44, 0x69, 0x67, 0x69, 0x74, 0x61, 0x6c, 0x20, 0x47, 0x61, + 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, + 0x37, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x66, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x5a, 0x44, 0x54, 0x20, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x5a, 0x65, 0x72, + 0x6f, 0x70, 0x6c, 0x75, 0x73, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, + 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x31, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x5a, 0x65, 0x72, 0x6f, 0x70, 0x6c, 0x75, 0x73, + 0x20, 0x50, 0x34, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x2c, 0x0d, 0x0a, 0x0d, 0x0a, 0x23, 0x20, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x32, 0x20, 0x49, 0x6e, 0x20, 0x31, 0x20, 0x4a, 0x6f, + 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, + 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, + 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, + 0x44, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20, 0x32, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x44, + 0x6f, 0x67, 0x62, 0x6f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x46, 0x43, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x46, + 0x43, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x35, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, + 0x65, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x32, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, + 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x32, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x35, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, + 0x65, 0x20, 0x53, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x53, 0x45, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, + 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x31, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, + 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, + 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, + 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, + 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, + 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x35, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x61, + 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, 0x53, + 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, + 0x61, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, + 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, + 0x45, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, + 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, + 0x4e, 0x45, 0x53, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, + 0x45, 0x53, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, + 0x53, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x35, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x33, 0x30, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x35, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x33, 0x30, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, + 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, + 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, + 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x33, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, + 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x38, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, + 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x53, 0x46, 0x43, 0x33, 0x30, 0x20, 0x4a, 0x6f, 0x79, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, + 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, + 0x53, 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, + 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x39, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, + 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, + 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x32, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, + 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, + 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, + 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, + 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, + 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, 0x6c, 0x75, 0x73, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, + 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, 0x6c, 0x75, 0x73, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x55, + 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x20, 0x57, 0x69, 0x72, 0x65, + 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, + 0x63, 0x31, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, + 0x65, 0x31, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, + 0x65, 0x32, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x55, + 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x20, 0x57, 0x69, 0x72, 0x65, + 0x6c, 0x65, 0x73, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x70, 0x61, + 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x70, 0x61, + 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x55, 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x20, 0x57, + 0x69, 0x72, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x32, 0x36, 0x2c, + 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x32, 0x33, 0x2c, + 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, + 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, + 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, + 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x33, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, + 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x39, 0x31, 0x39, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x39, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x6d, 0x61, 0x7a, + 0x6f, 0x6e, 0x20, 0x4c, 0x75, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, + 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x39, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x6d, 0x61, 0x7a, 0x6f, 0x6e, 0x20, + 0x4c, 0x75, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, + 0x73, 0x63, 0x31, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x37, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x41, 0x73, 0x74, 0x72, 0x6f, 0x20, 0x43, 0x69, 0x74, 0x79, + 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x41, 0x73, 0x74, 0x72, 0x6f, 0x20, 0x43, 0x69, + 0x74, 0x79, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, + 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x53, 0x55, 0x53, 0x20, 0x47, 0x61, + 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x53, 0x55, + 0x53, 0x20, 0x52, 0x4f, 0x47, 0x20, 0x4b, 0x75, 0x6e, 0x61, 0x69, 0x20, + 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, + 0x63, 0x31, 0x3a, 0x62, 0x34, 0x32, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, + 0x65, 0x31, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, + 0x32, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x41, 0x53, 0x55, 0x53, 0x20, 0x52, 0x4f, 0x47, 0x20, + 0x4b, 0x75, 0x6e, 0x61, 0x69, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x32, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x74, + 0x61, 0x72, 0x69, 0x20, 0x56, 0x43, 0x53, 0x20, 0x43, 0x6c, 0x61, 0x73, + 0x73, 0x69, 0x63, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x37, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, + 0x20, 0x56, 0x43, 0x53, 0x20, 0x4d, 0x6f, 0x64, 0x65, 0x72, 0x6e, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x38, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, + 0x44, 0x41, 0x20, 0x4d, 0x4f, 0x47, 0x41, 0x20, 0x58, 0x50, 0x35, 0x2d, + 0x58, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x62, 0x38, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, + 0x44, 0x41, 0x20, 0x4d, 0x4f, 0x47, 0x41, 0x20, 0x58, 0x50, 0x35, 0x2d, + 0x58, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x61, 0x37, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, + 0x44, 0x41, 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, + 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x20, + 0x4d, 0x61, 0x72, 0x73, 0x20, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, + 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x65, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x72, + 0x6f, 0x6f, 0x6b, 0x20, 0x4d, 0x61, 0x72, 0x73, 0x20, 0x50, 0x53, 0x34, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x62, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x43, 0x69, 0x64, 0x65, 0x6b, 0x6f, 0x20, 0x41, 0x4b, 0x30, + 0x38, 0x62, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x65, 0x63, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, 0x74, 0x68, 0x75, 0x6c, + 0x68, 0x75, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x36, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x38, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x43, 0x79, 0x62, 0x65, 0x72, 0x20, 0x47, 0x61, 0x64, 0x67, 0x65, 0x74, + 0x20, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x66, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, 0x79, 0x62, + 0x6f, 0x72, 0x67, 0x20, 0x56, 0x33, 0x20, 0x52, 0x75, 0x6d, 0x62, 0x6c, + 0x65, 0x20, 0x50, 0x61, 0x64, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2d, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x31, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x44, 0x75, 0x61, + 0x6c, 0x20, 0x42, 0x6f, 0x78, 0x20, 0x57, 0x69, 0x69, 0x20, 0x43, 0x6c, + 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, 0x6f, + 0x6d, 0x20, 0x4a, 0x43, 0x2d, 0x57, 0x30, 0x31, 0x55, 0x2c, 0x61, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x61, 0x63, + 0x65, 0x6f, 0x66, 0x66, 0x20, 0x50, 0x72, 0x65, 0x6d, 0x69, 0x65, 0x72, + 0x65, 0x20, 0x57, 0x69, 0x72, 0x65, 0x64, 0x20, 0x50, 0x72, 0x6f, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, + 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x6c, 0x79, + 0x64, 0x69, 0x67, 0x69, 0x20, 0x56, 0x61, 0x64, 0x65, 0x72, 0x20, 0x32, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x35, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x70, 0x61, + 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x61, 0x64, + 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x61, 0x64, 0x64, + 0x6c, 0x65, 0x33, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, + 0x6c, 0x65, 0x34, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, + 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x6c, 0x79, 0x64, 0x69, 0x67, 0x69, + 0x20, 0x56, 0x61, 0x64, 0x65, 0x72, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, + 0x62, 0x32, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, + 0x35, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x33, 0x3a, 0x62, 0x31, + 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x34, 0x3a, 0x62, 0x31, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, + 0x6c, 0x79, 0x64, 0x69, 0x67, 0x69, 0x20, 0x56, 0x61, 0x64, 0x65, 0x72, + 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x61, 0x64, + 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x70, 0x61, 0x64, + 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x70, 0x61, 0x64, + 0x64, 0x6c, 0x65, 0x33, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x70, 0x61, 0x64, + 0x64, 0x6c, 0x65, 0x34, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x36, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, + 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x35, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x36, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x35, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x34, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x31, 0x36, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x38, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x33, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x38, 0x2c, + 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x30, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, + 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x2d, 0x54, 0x33, 0x20, 0x32, 0x2e, + 0x30, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x66, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x73, + 0x74, 0x6f, 0x70, 0x20, 0x42, 0x42, 0x30, 0x37, 0x30, 0x20, 0x58, 0x33, + 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, + 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x37, 0x35, + 0x33, 0x32, 0x30, 0x34, 0x37, 0x36, 0x31, 0x36, 0x64, 0x36, 0x35, 0x37, + 0x30, 0x36, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, + 0x6d, 0x65, 0x53, 0x74, 0x6f, 0x70, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, + 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, + 0x74, 0x6f, 0x70, 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x75, 0x6e, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, + 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x74, 0x6f, 0x70, 0x20, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x66, 0x66, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x33, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x57, 0x61, 0x72, 0x65, 0x20, 0x50, + 0x43, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x20, 0x50, 0x61, + 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, 0x61, 0x76, 0x69, 0x73, + 0x20, 0x45, 0x6c, 0x69, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x20, + 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, 0x61, + 0x76, 0x69, 0x73, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x64, 0x20, + 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, 0x65, + 0x65, 0x6e, 0x41, 0x73, 0x69, 0x61, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, + 0x65, 0x72, 0x20, 0x33, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, + 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, + 0x61, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x34, 0x20, 0x50, 0x53, 0x33, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x35, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, + 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, + 0x72, 0x20, 0x34, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, + 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, + 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, + 0x6e, 0x64, 0x65, 0x72, 0x20, 0x34, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, + 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, + 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, + 0x20, 0x34, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, + 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, + 0x64, 0x65, 0x72, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, + 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, + 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, + 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x50, 0x53, + 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, + 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x20, + 0x4d, 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, + 0x69, 0x6e, 0x67, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x6d, 0x69, + 0x6e, 0x69, 0x20, 0x34, 0x20, 0x28, 0x50, 0x53, 0x33, 0x29, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, + 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, + 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, + 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x20, + 0x34, 0x20, 0x28, 0x50, 0x53, 0x34, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, + 0x20, 0x47, 0x65, 0x6d, 0x20, 0x50, 0x61, 0x64, 0x20, 0x33, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, + 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, 0x43, 0x20, 0x45, 0x6e, 0x67, + 0x69, 0x6e, 0x65, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, 0x6f, 0x6b, 0x6b, + 0x65, 0x6e, 0x20, 0x54, 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x6e, + 0x74, 0x20, 0x44, 0x58, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, + 0x30, 0x61, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, + 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, + 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, + 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x53, 0x77, + 0x69, 0x74, 0x63, 0x68, 0x20, 0x53, 0x70, 0x6c, 0x69, 0x74, 0x20, 0x50, + 0x61, 0x64, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x70, + 0x61, 0x64, 0x20, 0x34, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, + 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, + 0x6f, 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x34, 0x20, 0x50, 0x53, 0x34, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x46, + 0x50, 0x53, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x20, 0x34, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x65, 0x65, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x48, 0x6f, 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x4d, 0x69, 0x6e, 0x69, + 0x20, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, + 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x65, 0x30, 0x30, 0x30, 0x30, + 0x66, 0x66, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6b, 0x69, + 0x6e, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x65, + 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, + 0x4e, 0x36, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x69, 0x42, 0x75, 0x66, + 0x66, 0x61, 0x6c, 0x6f, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x66, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, + 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x20, 0x41, 0x78, 0x69, 0x73, + 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, + 0x72, 0x61, 0x63, 0x74, 0x20, 0x47, 0x6f, 0x50, 0x61, 0x64, 0x2c, 0x61, + 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x6f, + 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x4c, 0x29, 0x2c, 0x2b, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x2b, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x2d, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x2d, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, + 0x28, 0x52, 0x29, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, + 0x66, 0x30, 0x30, 0x30, 0x30, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x59, + 0x53, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x63, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x63, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x44, 0x75, 0x61, + 0x6c, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, + 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x63, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x44, 0x75, + 0x61, 0x6c, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x63, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x44, + 0x75, 0x61, 0x6c, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, + 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, + 0x46, 0x33, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, + 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, 0x35, 0x31, 0x30, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, + 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, + 0x46, 0x37, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, + 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, 0x37, 0x31, 0x30, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x38, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, + 0x65, 0x63, 0x68, 0x20, 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, 0x50, 0x61, + 0x64, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x7e, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, + 0x37, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, + 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x50, 0x53, 0x33, 0x20, 0x46, + 0x69, 0x67, 0x68, 0x74, 0x70, 0x61, 0x64, 0x20, 0x50, 0x72, 0x6f, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x33, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x50, + 0x53, 0x33, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x20, 0x54, 0x45, 0x20, 0x53, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x38, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x50, + 0x53, 0x34, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x70, 0x61, 0x64, 0x20, + 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x34, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, + 0x74, 0x7a, 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, 0x45, 0x20, 0x53, 0x20, 0x50, + 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x72, 0x76, 0x6f, 0x20, + 0x47, 0x54, 0x2d, 0x30, 0x30, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, + 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, + 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x34, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x36, 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x36, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x33, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, + 0x20, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x41, 0x64, + 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x34, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x31, 0x36, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x38, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x33, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x38, 0x2c, + 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x31, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, + 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x47, 0x61, 0x6d, 0x65, + 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, + 0x32, 0x66, 0x30, 0x30, 0x30, 0x30, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, + 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x4d, 0x61, 0x67, 0x69, + 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x32, + 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, + 0x4d, 0x61, 0x67, 0x69, 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x61, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, + 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x4d, 0x61, 0x67, 0x69, + 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, + 0x61, 0x73, 0x68, 0x20, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x41, + 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x62, 0x32, 0x38, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, + 0x33, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, + 0x32, 0x36, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x32, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x36, 0x2c, 0x79, 0x3a, + 0x62, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, + 0x30, 0x30, 0x30, 0x65, 0x38, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, + 0x6c, 0x61, 0x73, 0x68, 0x20, 0x57, 0x69, 0x69, 0x20, 0x43, 0x6c, 0x61, + 0x73, 0x73, 0x69, 0x63, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, + 0x73, 0x68, 0x20, 0x57, 0x69, 0x69, 0x20, 0x44, 0x6f, 0x6c, 0x70, 0x68, + 0x69, 0x6e, 0x42, 0x61, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x38, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x33, + 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x34, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x32, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, + 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x57, 0x69, 0x69, 0x20, + 0x55, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x38, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x33, 0x32, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x34, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x32, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x36, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x57, + 0x69, 0x69, 0x20, 0x55, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x41, 0x64, 0x61, + 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x3a, + 0x62, 0x38, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x33, 0x32, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x34, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x36, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, + 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, + 0x66, 0x74, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x53, 0x74, 0x72, 0x69, + 0x6b, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x7e, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, + 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, + 0x66, 0x74, 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, + 0x6f, 0x66, 0x74, 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, 0x64, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, + 0x73, 0x6f, 0x66, 0x74, 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, + 0x64, 0x65, 0x72, 0x20, 0x50, 0x6c, 0x75, 0x67, 0x20, 0x61, 0x6e, 0x64, + 0x20, 0x50, 0x6c, 0x61, 0x79, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, + 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x31, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x6f, 0x67, + 0x61, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x61, 0x38, 0x39, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x4f, + 0x47, 0x41, 0x20, 0x58, 0x50, 0x35, 0x41, 0x20, 0x50, 0x6c, 0x75, 0x73, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, + 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x62, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x4f, 0x47, 0x41, 0x20, 0x58, 0x50, + 0x35, 0x41, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x37, 0x35, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4e, 0x65, 0x6f, 0x47, 0x65, 0x6f, 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x20, + 0x50, 0x41, 0x44, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x31, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x62, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x45, 0x53, 0x20, + 0x32, 0x2d, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4e, 0x45, 0x58, 0x54, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, + 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x61, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, + 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, + 0x63, 0x68, 0x20, 0x43, 0x6f, 0x72, 0x65, 0x20, 0x50, 0x6c, 0x75, 0x73, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x61, + 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, + 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x41, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, + 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, + 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, + 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, + 0x66, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, + 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, + 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4e, 0x53, 0x4f, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x2b, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x38, 0x2c, 0x2b, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x37, 0x2c, 0x2d, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, + 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4e, 0x53, 0x4f, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x34, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, + 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x62, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4e, 0x79, 0x6b, 0x6f, 0x20, 0x41, 0x69, 0x72, 0x66, 0x6c, 0x6f, + 0x20, 0x45, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, 0x20, 0x50, 0x53, + 0x33, 0x20, 0x56, 0x65, 0x72, 0x73, 0x75, 0x73, 0x20, 0x46, 0x69, 0x67, + 0x68, 0x74, 0x69, 0x6e, 0x67, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, + 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x69, 0x72, 0x61, 0x6e, 0x68, 0x61, 0x20, 0x58, 0x74, 0x72, + 0x65, 0x6d, 0x65, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, + 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x36, 0x37, 0x30, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, + 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x41, + 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x64, 0x61, + 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, + 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x37, + 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x56, 0x69, 0x74, 0x61, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x64, 0x63, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, + 0x72, 0x41, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x45, 0x78, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x50, 0x53, 0x32, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, + 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, + 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x79, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, + 0x37, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x79, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, + 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x34, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x34, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, + 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x65, + 0x36, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x74, 0x6f, 0x75, 0x63, 0x68, 0x70, 0x61, 0x64, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x32, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x74, 0x6f, 0x75, 0x63, + 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, + 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x65, 0x36, 0x30, 0x63, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x74, 0x6f, 0x75, 0x63, 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x66, 0x32, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x74, 0x6f, 0x75, 0x63, + 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x50, 0x58, 0x4e, 0x20, 0x50, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, + 0x4d, 0x6f, 0x62, 0x69, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, 0x63, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, + 0x62, 0x61, 0x20, 0x44, 0x72, 0x61, 0x67, 0x6f, 0x6e, 0x20, 0x41, 0x72, + 0x63, 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x20, 0x28, 0x50, 0x53, 0x33, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, + 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, + 0x6e, 0x62, 0x61, 0x20, 0x44, 0x72, 0x6f, 0x6e, 0x65, 0x20, 0x41, 0x72, + 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, + 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x39, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x4f, 0x6e, 0x7a, 0x61, 0x20, + 0x54, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, + 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, + 0x61, 0x7a, 0x65, 0x72, 0x20, 0x50, 0x61, 0x6e, 0x74, 0x68, 0x65, 0x72, + 0x61, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, + 0x20, 0x50, 0x61, 0x6e, 0x74, 0x68, 0x65, 0x72, 0x61, 0x20, 0x50, 0x53, + 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, + 0x69, 0x6a, 0x75, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, + 0x52, 0x61, 0x69, 0x6a, 0x75, 0x20, 0x4d, 0x6f, 0x62, 0x69, 0x6c, 0x65, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, + 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, + 0x61, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x69, 0x67, + 0x68, 0x74, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, + 0x72, 0x20, 0x53, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x36, 0x33, 0x61, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, + 0x65, 0x72, 0x20, 0x53, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x61, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, + 0x7a, 0x65, 0x72, 0x20, 0x57, 0x69, 0x6c, 0x64, 0x63, 0x61, 0x74, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x32, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x64, 0x67, + 0x65, 0x61, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x20, + 0x42, 0x69, 0x74, 0x20, 0x53, 0x65, 0x67, 0x61, 0x20, 0x47, 0x65, 0x6e, + 0x65, 0x73, 0x69, 0x73, 0x20, 0x36, 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x32, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x34, 0x37, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x52, 0x65, 0x74, 0x72, 0x6f, 0x20, 0x42, 0x69, 0x74, 0x20, 0x53, 0x65, + 0x67, 0x61, 0x20, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, + 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, + 0x61, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x78, + 0x3a, 0x62, 0x36, 0x2c, 0x79, 0x3a, 0x62, 0x38, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, + 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x52, 0x65, 0x74, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, + 0x74, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, + 0x6f, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, + 0x61, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, + 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, + 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, + 0x6f, 0x55, 0x53, 0x42, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x52, 0x65, 0x74, + 0x72, 0x6f, 0x50, 0x6f, 0x72, 0x74, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x62, 0x38, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x62, 0x39, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x37, 0x2c, 0x62, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x32, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x34, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x76, 0x6f, 0x6c, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x76, 0x6f, + 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x33, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x52, 0x69, 0x69, 0x20, 0x52, 0x4b, 0x37, 0x30, 0x37, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x79, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x66, 0x65, 0x66, 0x61, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, + 0x63, 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, 0x50, 0x53, 0x33, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, 0x63, + 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, 0x53, 0x77, 0x69, 0x74, + 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x62, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x6d, 0x73, 0x75, 0x6e, + 0x67, 0x20, 0x45, 0x49, 0x47, 0x50, 0x32, 0x30, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, + 0x78, 0x3a, 0x62, 0x37, 0x2c, 0x79, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x33, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x53, 0x61, 0x6e, 0x77, 0x61, 0x20, 0x50, 0x6c, 0x61, + 0x79, 0x4f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x4d, 0x6f, 0x62, 0x69, + 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x2d, 0x61, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, 0x47, + 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, + 0x33, 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, + 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x31, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x36, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, + 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x61, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, 0x53, 0x61, + 0x74, 0x75, 0x72, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x35, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x61, 0x62, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x53, 0x46, 0x43, 0x33, 0x30, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x52, 0x65, 0x74, 0x72, + 0x6f, 0x50, 0x6f, 0x72, 0x74, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x61, + 0x30, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x53, 0x6f, 0x6e, 0x79, 0x20, 0x44, 0x75, 0x61, + 0x6c, 0x53, 0x68, 0x6f, 0x63, 0x6b, 0x20, 0x34, 0x20, 0x41, 0x64, 0x61, + 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x6f, 0x6e, 0x79, + 0x20, 0x44, 0x75, 0x61, 0x6c, 0x53, 0x68, 0x6f, 0x63, 0x6b, 0x20, 0x34, + 0x20, 0x56, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x31, 0x31, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x61, 0x64, 0x69, + 0x61, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, + 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, 0x56, 0x69, 0x72, 0x74, 0x75, + 0x61, 0x6c, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, + 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x4e, 0x69, 0x6d, + 0x62, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x39, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x7e, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, + 0x69, 0x65, 0x73, 0x20, 0x4e, 0x69, 0x6d, 0x62, 0x75, 0x73, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x38, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, + 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x4e, + 0x69, 0x6d, 0x62, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, + 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x7e, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x7e, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x34, 0x39, 0x34, 0x34, 0x32, + 0x30, 0x34, 0x34, 0x36, 0x35, 0x37, 0x36, 0x36, 0x39, 0x36, 0x33, 0x36, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, + 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x4e, 0x69, 0x6d, 0x62, 0x75, 0x73, + 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x7e, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x65, 0x36, 0x39, 0x36, 0x64, 0x36, + 0x32, 0x37, 0x35, 0x37, 0x33, 0x32, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, + 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x4e, 0x69, 0x6d, 0x62, 0x75, 0x73, + 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x7e, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, + 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, 0x74, 0x75, + 0x73, 0x20, 0x44, 0x75, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x31, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, + 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, 0x74, 0x75, 0x73, 0x20, 0x44, 0x75, + 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, 0x31, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, + 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x53, 0x74, + 0x72, 0x61, 0x74, 0x75, 0x73, 0x20, 0x58, 0x4c, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, + 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x53, 0x74, 0x72, + 0x61, 0x74, 0x75, 0x73, 0x20, 0x58, 0x4c, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x7e, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x77, 0x69, 0x74, + 0x63, 0x68, 0x20, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, 0x61, 0x64, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x35, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x32, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x53, 0x5a, 0x4d, 0x59, 0x20, 0x50, 0x6f, 0x77, + 0x65, 0x72, 0x20, 0x50, 0x43, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, + 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x63, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x54, 0x47, 0x5a, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, + 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x39, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x54, 0x48, 0x45, 0x43, 0x36, 0x34, 0x20, 0x4a, 0x6f, 0x79, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x39, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x54, 0x48, 0x45, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x62, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, + 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, + 0x44, 0x75, 0x61, 0x6c, 0x20, 0x41, 0x6e, 0x61, 0x6c, 0x6f, 0x67, 0x20, + 0x33, 0x2e, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x65, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, + 0x73, 0x74, 0x4d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x65, 0x53, 0x77, + 0x61, 0x70, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, + 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x46, 0x69, 0x72, + 0x65, 0x73, 0x74, 0x6f, 0x72, 0x6d, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, + 0x50, 0x6f, 0x77, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, + 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x37, 0x31, 0x64, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x6f, 0x6d, 0x65, 0x65, 0x20, 0x4e, + 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, + 0x61, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, + 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x62, 0x64, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x54, 0x6f, 0x6d, 0x65, 0x65, 0x20, 0x52, 0x65, 0x74, 0x72, 0x6f, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x64, 0x31, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x64, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x6f, + 0x6d, 0x65, 0x65, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x37, 0x31, 0x64, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x6f, 0x6d, 0x65, 0x65, 0x20, + 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x66, 0x31, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x63, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x72, + 0x75, 0x73, 0x74, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, + 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, + 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x54, 0x77, 0x69, 0x6e, 0x20, 0x55, 0x53, 0x42, 0x20, 0x4a, + 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x34, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x32, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x36, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, + 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x36, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x62, 0x65, 0x72, 0x77, 0x69, 0x74, + 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x36, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x6e, 0x69, 0x70, 0x6c, + 0x61, 0x79, 0x20, 0x55, 0x36, 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, 0x62, + 0x3a, 0x62, 0x36, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x35, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x33, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x33, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x32, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, + 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x56, 0x69, 0x63, 0x74, 0x72, 0x69, + 0x78, 0x20, 0x50, 0x53, 0x34, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x46, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x56, 0x69, 0x63, 0x74, 0x72, 0x69, 0x78, 0x20, + 0x50, 0x53, 0x34, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x46, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x37, 0x36, 0x39, 0x36, 0x39, 0x36, 0x64, 0x36, + 0x66, 0x37, 0x34, 0x36, 0x35, 0x32, 0x30, 0x32, 0x38, 0x33, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x2c, 0x57, 0x69, 0x69, 0x20, 0x52, 0x65, 0x6d, 0x6f, + 0x74, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x35, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x32, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, + 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x37, 0x36, 0x39, 0x36, 0x39, 0x36, 0x64, 0x36, 0x66, 0x37, 0x34, + 0x36, 0x35, 0x32, 0x30, 0x32, 0x38, 0x33, 0x31, 0x33, 0x38, 0x30, 0x30, + 0x2c, 0x57, 0x69, 0x69, 0x20, 0x55, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x36, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, + 0x62, 0x31, 0x38, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, + 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x64, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, + 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x41, 0x64, 0x61, 0x70, + 0x74, 0x69, 0x76, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x58, 0x62, 0x6f, 0x78, 0x20, 0x45, 0x6c, 0x69, 0x74, 0x65, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x53, 0x65, + 0x72, 0x69, 0x65, 0x73, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x33, + 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x62, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x62, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x62, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x35, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x64, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x64, 0x64, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x65, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, + 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, + 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x33, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, + 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x65, 0x61, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, + 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x33, 0x61, 0x35, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x50, 0x6f, 0x77, 0x65, + 0x72, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, + 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x62, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, + 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, + 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, + 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, + 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, + 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x35, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, + 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, + 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x33, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, + 0x69, 0x61, 0x6f, 0x4d, 0x69, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x36, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x5a, 0x65, 0x72, + 0x6f, 0x70, 0x6c, 0x75, 0x73, 0x20, 0x50, 0x34, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, + 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x65, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x5a, + 0x65, 0x72, 0x6f, 0x70, 0x6c, 0x75, 0x73, 0x20, 0x50, 0x34, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, + 0x58, 0x2c, 0x0d, 0x0a, 0x0d, 0x0a, 0x23, 0x20, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, + 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x44, 0x6f, + 0x67, 0x62, 0x6f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x46, 0x43, 0x33, + 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x46, 0x43, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x46, + 0x43, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, + 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x35, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, + 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x32, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x35, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, + 0x65, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, + 0x4c, 0x69, 0x74, 0x65, 0x20, 0x53, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x53, 0x45, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, + 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x35, 0x31, 0x30, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, + 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, + 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x20, 0x50, + 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x35, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, + 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, + 0x45, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x4e, 0x45, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, + 0x45, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x38, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, 0x53, 0x33, + 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, 0x53, 0x33, 0x30, 0x20, 0x50, 0x72, + 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, + 0x4e, 0x45, 0x53, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x38, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, 0x53, 0x33, + 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x50, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x33, + 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, + 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, + 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, + 0x72, 0x6f, 0x20, 0x32, 0x20, 0x57, 0x69, 0x72, 0x65, 0x64, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x20, 0x57, 0x69, 0x72, 0x65, + 0x64, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, + 0x20, 0x32, 0x20, 0x57, 0x69, 0x72, 0x65, 0x64, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x58, 0x62, 0x6f, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, + 0x20, 0x32, 0x20, 0x57, 0x69, 0x72, 0x65, 0x64, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x58, 0x62, 0x6f, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, + 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, + 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x33, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, + 0x69, 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, + 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x38, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x53, 0x46, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, 0x33, 0x30, + 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x32, 0x61, 0x62, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, + 0x53, 0x46, 0x43, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x61, 0x62, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, 0x43, 0x33, + 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x61, 0x62, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, 0x43, 0x33, 0x30, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x53, 0x46, 0x43, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, + 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, + 0x53, 0x46, 0x43, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, + 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, + 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, + 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, + 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, + 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, + 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, + 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, + 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x32, + 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, + 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, + 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, + 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, + 0x53, 0x4e, 0x45, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, + 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x39, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, + 0x32, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, + 0x44, 0x6f, 0x20, 0x55, 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x20, + 0x57, 0x69, 0x72, 0x65, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x70, + 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x70, + 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, + 0x55, 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x20, 0x57, 0x69, 0x72, + 0x65, 0x6c, 0x65, 0x73, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x55, 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, + 0x20, 0x57, 0x69, 0x72, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, + 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, + 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x55, 0x6c, 0x74, 0x69, 0x6d, 0x61, + 0x74, 0x65, 0x20, 0x57, 0x69, 0x72, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, + 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, + 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, + 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, + 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, + 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, + 0x6e, 0x65, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x58, 0x62, 0x6f, 0x78, + 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, + 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x61, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, + 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x5a, 0x65, + 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, + 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x33, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, + 0x44, 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, + 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, + 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x31, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x35, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x63, + 0x72, 0x75, 0x78, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, + 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x33, 0x39, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, + 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x50, 0x72, 0x69, + 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x33, 0x39, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, + 0x20, 0x50, 0x72, 0x69, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x30, 0x34, + 0x38, 0x2d, 0x30, 0x30, 0x37, 0x2d, 0x4e, 0x41, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, + 0x6c, 0x6f, 0x77, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, + 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, + 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x41, 0x6b, 0x69, 0x73, 0x68, 0x6f, 0x70, 0x20, 0x43, 0x75, 0x73, 0x74, + 0x6f, 0x6d, 0x73, 0x20, 0x50, 0x53, 0x33, 0x36, 0x30, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x63, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x41, 0x6c, 0x69, 0x65, 0x6e, 0x77, 0x61, 0x72, 0x65, 0x20, + 0x44, 0x75, 0x61, 0x6c, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, + 0x62, 0x6c, 0x65, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x20, 0x50, 0x6c, 0x61, + 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x39, 0x31, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x6d, 0x61, + 0x7a, 0x6f, 0x6e, 0x20, 0x46, 0x69, 0x72, 0x65, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x39, 0x31, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x39, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x6d, 0x61, 0x7a, 0x6f, + 0x6e, 0x20, 0x4c, 0x75, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, + 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x41, 0x6d, 0x61, 0x7a, 0x6f, 0x6e, 0x20, 0x4c, 0x75, 0x6e, 0x61, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x72, 0x63, 0x61, 0x64, + 0x65, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x20, 0x46, 0x33, 0x30, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x41, 0x73, 0x74, 0x72, 0x6f, 0x20, 0x43, 0x69, + 0x74, 0x79, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x41, 0x73, 0x74, 0x72, 0x6f, 0x20, 0x43, 0x69, 0x74, + 0x79, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x41, 0x53, 0x55, 0x53, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, + 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, + 0x53, 0x55, 0x53, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x53, 0x55, + 0x53, 0x20, 0x52, 0x4f, 0x47, 0x20, 0x4b, 0x75, 0x6e, 0x61, 0x69, 0x20, + 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, + 0x63, 0x31, 0x3a, 0x62, 0x33, 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, + 0x65, 0x31, 0x3a, 0x62, 0x35, 0x32, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, + 0x65, 0x32, 0x3a, 0x62, 0x35, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x37, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x41, 0x53, 0x55, 0x53, 0x20, 0x52, 0x4f, 0x47, 0x20, 0x4b, 0x75, + 0x6e, 0x61, 0x69, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x70, + 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x70, + 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, 0x20, 0x43, + 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, + 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, + 0x72, 0x69, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, + 0x74, 0x61, 0x72, 0x69, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, + 0x69, 0x63, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, + 0x72, 0x69, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, + 0x74, 0x61, 0x72, 0x69, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, 0x20, 0x56, 0x43, 0x53, 0x20, 0x4d, + 0x6f, 0x64, 0x65, 0x72, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x2b, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x62, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x42, 0x44, 0x41, 0x20, 0x4d, 0x4f, 0x47, 0x41, + 0x20, 0x58, 0x50, 0x35, 0x58, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, + 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x61, 0x37, 0x39, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x42, 0x44, 0x41, 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x69, 0x67, 0x68, + 0x74, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x32, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, 0x31, 0x20, 0x47, 0x43, 0x31, 0x30, + 0x31, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x20, 0x31, 0x2e, 0x30, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x33, 0x31, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, 0x31, 0x20, 0x47, + 0x43, 0x31, 0x30, 0x31, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x20, 0x31, 0x2e, 0x30, 0x33, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, + 0x31, 0x20, 0x47, 0x43, 0x31, 0x30, 0x31, 0x20, 0x58, 0x62, 0x6f, 0x78, + 0x20, 0x33, 0x36, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x62, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x64, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x42, 0x45, 0x49, 0x54, 0x4f, 0x4e, 0x47, 0x20, 0x41, 0x31, + 0x54, 0x32, 0x20, 0x42, 0x46, 0x4d, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x63, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x45, 0x54, 0x4f, + 0x50, 0x20, 0x41, 0x58, 0x31, 0x20, 0x42, 0x46, 0x4d, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x63, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x31, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, + 0x65, 0x74, 0x6f, 0x70, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x42, 0x69, 0x67, 0x62, 0x65, 0x6e, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, + 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x65, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, + 0x72, 0x6f, 0x6f, 0x6b, 0x20, 0x4d, 0x61, 0x72, 0x73, 0x20, 0x50, 0x53, + 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x65, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x20, 0x4d, 0x61, 0x72, 0x73, 0x20, 0x50, + 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x66, 0x37, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x20, 0x55, 0x6e, 0x69, 0x76, 0x65, + 0x72, 0x73, 0x61, 0x6c, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, + 0x67, 0x20, 0x42, 0x6f, 0x61, 0x72, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x65, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x30, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, 0x69, 0x64, 0x65, 0x6b, 0x6f, 0x20, + 0x41, 0x4b, 0x30, 0x38, 0x62, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x33, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, 0x6f, 0x6d, 0x70, 0x65, + 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, + 0x39, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x38, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, 0x79, + 0x62, 0x65, 0x72, 0x20, 0x47, 0x61, 0x64, 0x67, 0x65, 0x74, 0x20, 0x47, + 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x32, 0x66, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x43, 0x79, 0x62, 0x6f, 0x72, 0x67, 0x20, 0x56, + 0x33, 0x20, 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x31, + 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x44, 0x75, + 0x61, 0x6c, 0x20, 0x42, 0x6f, 0x78, 0x20, 0x57, 0x69, 0x69, 0x20, 0x43, + 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x41, 0x20, + 0x53, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x31, 0x31, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x61, 0x73, + 0x79, 0x53, 0x4d, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x61, 0x73, 0x79, 0x53, 0x4d, + 0x58, 0x20, 0x45, 0x53, 0x4d, 0x2d, 0x39, 0x31, 0x30, 0x31, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, + 0x6f, 0x6d, 0x20, 0x55, 0x33, 0x36, 0x31, 0x33, 0x4d, 0x2c, 0x61, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x65, + 0x63, 0x6f, 0x6d, 0x20, 0x57, 0x30, 0x31, 0x55, 0x2c, 0x61, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x69, 0x6d, 0x69, 0x6e, 0x61, + 0x74, 0x6f, 0x72, 0x20, 0x41, 0x66, 0x74, 0x65, 0x72, 0x53, 0x68, 0x6f, + 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x2d, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x30, 0x62, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x4d, 0x53, 0x20, 0x50, + 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x53, + 0x32, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, + 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x35, 0x30, 0x33, 0x36, 0x38, 0x35, 0x32, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x69, 0x6e, 0x61, 0x6c, + 0x20, 0x46, 0x61, 0x6e, 0x74, 0x61, 0x73, 0x79, 0x20, 0x58, 0x49, 0x56, + 0x20, 0x4f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x6c, 0x79, 0x64, + 0x69, 0x67, 0x69, 0x20, 0x56, 0x61, 0x64, 0x65, 0x72, 0x20, 0x32, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, + 0x63, 0x31, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, + 0x65, 0x31, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, + 0x32, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x33, + 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x34, + 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, + 0x6c, 0x79, 0x64, 0x69, 0x67, 0x69, 0x20, 0x56, 0x61, 0x64, 0x65, 0x72, + 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x61, 0x64, + 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x70, 0x61, 0x64, + 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x70, 0x61, 0x64, + 0x64, 0x6c, 0x65, 0x33, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x70, 0x61, 0x64, + 0x64, 0x6c, 0x65, 0x34, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x35, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x46, 0x6c, 0x79, 0x64, 0x69, 0x67, 0x69, 0x20, 0x56, + 0x61, 0x64, 0x65, 0x72, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x61, + 0x64, 0x64, 0x6c, 0x65, 0x33, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x70, 0x61, + 0x64, 0x64, 0x6c, 0x65, 0x34, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x37, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, + 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, + 0x61, 0x6d, 0x65, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x35, 0x62, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x20, 0x47, + 0x33, 0x77, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x62, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x20, 0x47, 0x33, + 0x77, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x62, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, + 0x20, 0x47, 0x34, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, 0x64, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x62, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, + 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x20, 0x47, 0x34, 0x73, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x33, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, + 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x35, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x47, 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x20, 0x54, 0x34, 0x77, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x30, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, + 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x2d, 0x54, 0x33, 0x20, 0x32, 0x2e, + 0x30, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x37, 0x35, 0x33, 0x32, 0x30, 0x34, 0x37, 0x36, + 0x31, 0x36, 0x64, 0x36, 0x35, 0x37, 0x30, 0x36, 0x31, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x74, 0x6f, 0x70, + 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, + 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, + 0x6d, 0x65, 0x73, 0x74, 0x6f, 0x70, 0x20, 0x4c, 0x6f, 0x67, 0x69, 0x63, + 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, + 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, + 0x73, 0x69, 0x61, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, + 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x35, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x47, 0x65, 0x6e, 0x69, 0x75, 0x73, 0x20, 0x4d, 0x61, 0x78, 0x66, + 0x69, 0x72, 0x65, 0x20, 0x47, 0x72, 0x61, 0x6e, 0x64, 0x69, 0x61, 0x73, + 0x20, 0x31, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x31, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x62, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x4f, 0x2d, 0x41, 0x64, 0x76, 0x61, + 0x6e, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x62, + 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, + 0x4f, 0x2d, 0x41, 0x64, 0x76, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, + 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x62, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x47, 0x4f, 0x2d, 0x53, 0x75, 0x70, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x39, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x66, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x31, + 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x47, 0x6f, 0x6f, 0x64, 0x62, 0x65, 0x74, 0x74, 0x65, + 0x72, 0x62, 0x65, 0x73, 0x74, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, + 0x34, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x47, 0x50, 0x44, 0x20, 0x57, 0x69, 0x6e, 0x20, + 0x32, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x64, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, + 0x61, 0x76, 0x69, 0x73, 0x20, 0x45, 0x6c, 0x69, 0x6d, 0x69, 0x6e, 0x61, + 0x74, 0x6f, 0x72, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, + 0x61, 0x76, 0x69, 0x73, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x64, + 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, 0x65, 0x65, 0x6e, + 0x41, 0x73, 0x69, 0x61, 0x20, 0x45, 0x6c, 0x65, 0x63, 0x74, 0x72, 0x6f, + 0x6e, 0x69, 0x63, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x41, 0x73, + 0x69, 0x61, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x37, 0x35, 0x33, 0x32, 0x30, 0x36, 0x37, 0x36, 0x31, 0x36, 0x64, + 0x36, 0x35, 0x37, 0x30, 0x36, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x47, 0x53, 0x20, 0x67, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x66, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x33, 0x38, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x47, 0x54, 0x20, 0x56, 0x58, 0x32, 0x2c, 0x61, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x64, + 0x65, 0x30, 0x30, 0x30, 0x30, 0x65, 0x66, 0x62, 0x65, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x69, + 0x64, 0x72, 0x6f, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x72, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, 0x31, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x69, 0x74, 0x42, 0x6f, 0x78, + 0x20, 0x50, 0x53, 0x33, 0x20, 0x50, 0x43, 0x20, 0x41, 0x6e, 0x61, 0x6c, + 0x6f, 0x67, 0x20, 0x4d, 0x6f, 0x64, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x39, 0x31, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x4a, 0x43, 0x20, + 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x32, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x4a, 0x44, + 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x36, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, + 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x45, 0x44, + 0x47, 0x45, 0x20, 0x33, 0x30, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x2b, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, + 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, + 0x61, 0x6e, 0x64, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, + 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, + 0x6e, 0x64, 0x65, 0x72, 0x20, 0x34, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, + 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, + 0x6e, 0x64, 0x65, 0x72, 0x20, 0x34, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, + 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, + 0x6e, 0x64, 0x65, 0x72, 0x20, 0x4f, 0x43, 0x54, 0x41, 0x20, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, + 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, + 0x64, 0x65, 0x72, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, + 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, + 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, + 0x33, 0x36, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x33, 0x37, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x4d, + 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, + 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x53, 0x74, 0x69, + 0x63, 0x6b, 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x20, 0x34, 0x20, 0x28, 0x50, + 0x53, 0x33, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, + 0x6e, 0x67, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x6d, 0x69, 0x6e, + 0x69, 0x20, 0x34, 0x20, 0x28, 0x50, 0x53, 0x34, 0x29, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, + 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x33, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x66, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x33, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x56, 0x58, 0x2c, + 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x47, 0x65, + 0x6d, 0x20, 0x50, 0x61, 0x64, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x66, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x33, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, + 0x50, 0x61, 0x64, 0x20, 0x45, 0x58, 0x20, 0x54, 0x75, 0x72, 0x62, 0x6f, + 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, 0x43, 0x20, 0x45, 0x6e, 0x67, 0x69, + 0x6e, 0x65, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, + 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, + 0x6f, 0x72, 0x69, 0x20, 0x50, 0x6f, 0x6b, 0x6b, 0x65, 0x6e, 0x20, 0x54, + 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x44, 0x58, + 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, + 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x61, 0x61, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, + 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, + 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, + 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, + 0x50, 0x72, 0x6f, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, + 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, + 0x6f, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, + 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, + 0x20, 0x50, 0x72, 0x6f, 0x20, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, + 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, + 0x72, 0x6f, 0x20, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, + 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, + 0x20, 0x45, 0x58, 0x53, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, + 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, + 0x72, 0x69, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x53, 0x70, + 0x6c, 0x69, 0x74, 0x20, 0x50, 0x61, 0x64, 0x20, 0x50, 0x72, 0x6f, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, + 0x69, 0x70, 0x61, 0x64, 0x20, 0x34, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, + 0x66, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, + 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x34, 0x20, 0x50, 0x53, 0x34, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, + 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x65, 0x65, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, + 0x6f, 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, + 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x36, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x4f, 0x6e, 0x65, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, + 0x66, 0x30, 0x30, 0x30, 0x30, 0x63, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, + 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, + 0x30, 0x30, 0x66, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x70, + 0x61, 0x64, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, 0x72, + 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x34, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x66, 0x37, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x48, 0x75, 0x69, 0x4a, 0x69, 0x61, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x43, + 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x34, 0x32, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, + 0x41, 0x64, 0x6d, 0x69, 0x72, 0x61, 0x6c, 0x20, 0x4e, 0x36, 0x34, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x2b, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x2b, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x2d, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x38, 0x2c, 0x2d, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x34, 0x32, 0x65, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x62, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x4e, 0x36, + 0x34, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x65, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x61, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x79, 0x70, 0x65, + 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x54, 0x72, 0x6f, 0x6f, 0x70, 0x65, 0x72, + 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, + 0x32, 0x65, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x31, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, + 0x79, 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x58, 0x39, 0x31, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x64, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x79, 0x70, + 0x65, 0x72, 0x58, 0x20, 0x43, 0x6c, 0x75, 0x74, 0x63, 0x68, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x69, 0x42, 0x75, 0x66, 0x66, 0x61, 0x6c, 0x6f, 0x20, 0x53, 0x4e, 0x45, + 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x39, 0x36, 0x34, 0x37, + 0x32, 0x36, 0x66, 0x36, 0x39, 0x36, 0x34, 0x33, 0x61, 0x36, 0x33, 0x36, + 0x66, 0x36, 0x65, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x69, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x63, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x35, 0x30, 0x37, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x35, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6d, 0x70, 0x61, 0x63, 0x74, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x49, 0x4d, 0x53, 0x20, 0x50, 0x43, 0x55, 0x30, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, + 0x65, 0x72, 0x41, 0x63, 0x74, 0x20, 0x41, 0x78, 0x69, 0x73, 0x50, 0x61, + 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x65, 0x66, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x20, + 0x41, 0x78, 0x69, 0x73, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, + 0x65, 0x72, 0x41, 0x63, 0x74, 0x20, 0x47, 0x6f, 0x50, 0x61, 0x64, 0x2c, + 0x61, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x61, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, + 0x72, 0x41, 0x63, 0x74, 0x20, 0x48, 0x61, 0x6d, 0x6d, 0x65, 0x72, 0x48, + 0x65, 0x61, 0x64, 0x20, 0x46, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, + 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x39, 0x31, 0x39, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x62, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x70, 0x65, 0x67, + 0x61, 0x20, 0x50, 0x47, 0x20, 0x39, 0x30, 0x36, 0x39, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x36, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x37, 0x35, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x49, 0x70, 0x65, 0x67, 0x61, 0x20, 0x50, 0x47, 0x20, 0x39, 0x30, 0x39, + 0x39, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x39, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x62, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x49, 0x70, 0x65, 0x67, 0x61, 0x20, 0x50, 0x47, 0x39, + 0x30, 0x39, 0x39, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x39, 0x31, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x70, 0x65, 0x67, 0x61, + 0x20, 0x50, 0x47, 0x39, 0x31, 0x31, 0x38, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, + 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, + 0x65, 0x73, 0x73, 0x20, 0x54, 0x65, 0x63, 0x68, 0x20, 0x44, 0x75, 0x61, + 0x6c, 0x20, 0x41, 0x6e, 0x61, 0x6c, 0x6f, 0x67, 0x20, 0x52, 0x75, 0x6d, + 0x62, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x62, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x65, 0x73, 0x73, 0x20, 0x54, 0x65, + 0x63, 0x68, 0x20, 0x47, 0x47, 0x45, 0x39, 0x30, 0x39, 0x20, 0x50, 0x43, + 0x20, 0x52, 0x65, 0x63, 0x6f, 0x69, 0x6c, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x61, 0x32, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x65, 0x73, + 0x73, 0x20, 0x54, 0x65, 0x63, 0x68, 0x6e, 0x6f, 0x6c, 0x6f, 0x67, 0x79, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, + 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x4c, 0x29, 0x2c, 0x2b, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x2b, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x2d, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x2d, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, + 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x4c, 0x29, 0x2c, 0x2b, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x2b, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x2d, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x2d, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x52, + 0x29, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, + 0x20, 0x28, 0x52, 0x29, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x64, 0x31, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x6f, 0x79, 0x70, + 0x61, 0x64, 0x20, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x20, 0x53, 0x68, 0x6f, + 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x59, 0x53, 0x20, 0x41, 0x64, 0x61, 0x70, + 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x61, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4a, 0x59, 0x53, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x34, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, + 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, + 0x67, 0x69, 0x63, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x64, 0x31, 0x63, 0x61, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x43, 0x68, + 0x69, 0x6c, 0x6c, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x63, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, + 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x72, 0x64, + 0x6c, 0x65, 0x73, 0x73, 0x20, 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, 0x50, + 0x61, 0x64, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x36, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, + 0x63, 0x68, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x41, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x36, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, + 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x64, 0x63, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, + 0x33, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x63, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, 0x35, + 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x63, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, 0x35, 0x31, + 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x63, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, + 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, 0x37, 0x31, 0x30, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x63, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, + 0x37, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x63, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x52, 0x75, + 0x6d, 0x62, 0x6c, 0x65, 0x50, 0x61, 0x64, 0x20, 0x32, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x63, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, + 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x57, 0x69, 0x6e, 0x67, + 0x4d, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x72, 0x64, 0x6c, 0x65, 0x73, 0x73, + 0x20, 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, 0x50, 0x61, 0x64, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x61, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, + 0x68, 0x20, 0x57, 0x69, 0x6e, 0x67, 0x4d, 0x61, 0x6e, 0x20, 0x52, 0x75, + 0x6d, 0x62, 0x6c, 0x65, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x36, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, + 0x61, 0x74, 0x7a, 0x20, 0x43, 0x54, 0x52, 0x4c, 0x52, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x35, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, + 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x70, + 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, + 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x70, 0x61, 0x64, + 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x30, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, + 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x70, 0x61, + 0x64, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x65, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, + 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x70, + 0x61, 0x64, 0x20, 0x53, 0x46, 0x78, 0x54, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, + 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, + 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x30, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, + 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, + 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x33, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, + 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, 0x45, 0x20, 0x53, 0x20, + 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, + 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, + 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, + 0x45, 0x20, 0x53, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x38, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, + 0x61, 0x74, 0x7a, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x38, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, + 0x61, 0x74, 0x7a, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x36, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, + 0x43, 0x61, 0x74, 0x7a, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, + 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, + 0x37, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x34, 0x37, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, + 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, + 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, + 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, + 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, + 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, + 0x61, 0x6e, 0x74, 0x61, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x73, 0x68, 0x6f, + 0x63, 0x6b, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, + 0x73, 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, + 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, + 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x41, 0x64, 0x61, + 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x31, 0x38, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x47, 0x61, + 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, + 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, + 0x66, 0x30, 0x30, 0x30, 0x30, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, + 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x4d, 0x61, 0x67, 0x69, 0x63, + 0x20, 0x4e, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x32, 0x31, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, + 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x4d, 0x61, 0x67, 0x69, + 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x61, 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, + 0x20, 0x4d, 0x61, 0x67, 0x69, 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, + 0x32, 0x66, 0x30, 0x30, 0x30, 0x30, 0x66, 0x37, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, + 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x4d, 0x61, 0x67, 0x69, + 0x63, 0x20, 0x53, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, + 0x68, 0x20, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x41, 0x64, 0x61, + 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x65, 0x38, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, + 0x57, 0x69, 0x69, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, + 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, + 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x57, + 0x69, 0x69, 0x20, 0x44, 0x6f, 0x6c, 0x70, 0x68, 0x69, 0x6e, 0x42, 0x61, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, + 0x6c, 0x61, 0x73, 0x68, 0x20, 0x57, 0x69, 0x69, 0x20, 0x55, 0x20, 0x50, + 0x72, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, + 0x35, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4d, 0x65, 0x67, 0x61, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x20, 0x4c, + 0x6f, 0x67, 0x69, 0x63, 0x20, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x35, 0x30, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x65, 0x67, 0x61, 0x20, + 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x20, 0x4c, 0x6f, 0x67, 0x69, 0x63, 0x20, + 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x6e, 0x74, 0x65, 0x6b, 0x20, + 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, + 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x44, 0x75, 0x61, 0x6c, + 0x20, 0x53, 0x74, 0x72, 0x69, 0x6b, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x33, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x7e, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, + 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, + 0x73, 0x6f, 0x66, 0x74, 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, + 0x64, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, + 0x66, 0x74, 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, + 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x20, + 0x46, 0x72, 0x65, 0x65, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x20, 0x50, 0x72, + 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x53, + 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x50, 0x6c, + 0x75, 0x67, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x35, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x58, 0x62, + 0x6f, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, + 0x58, 0x62, 0x6f, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x65, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, + 0x74, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, + 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x58, 0x62, 0x6f, + 0x78, 0x20, 0x33, 0x36, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x32, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, + 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, + 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, + 0x73, 0x6f, 0x66, 0x74, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, + 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x64, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, + 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x58, 0x62, 0x6f, + 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x64, 0x31, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, + 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x64, 0x64, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, + 0x73, 0x6f, 0x66, 0x74, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, + 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x61, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, + 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x58, 0x62, 0x6f, + 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, + 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, + 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x65, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, + 0x66, 0x74, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, + 0x45, 0x6c, 0x69, 0x74, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, + 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x45, 0x6c, + 0x69, 0x74, 0x65, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, + 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x45, 0x6c, + 0x69, 0x74, 0x65, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x32, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, + 0x73, 0x6f, 0x66, 0x74, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, + 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4d, 0x69, 0x72, 0x6f, 0x6f, 0x66, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x64, 0x34, 0x66, 0x34, 0x33, 0x35, 0x35, 0x35, 0x34, 0x34, + 0x35, 0x32, 0x64, 0x33, 0x30, 0x33, 0x35, 0x33, 0x33, 0x35, 0x38, 0x30, + 0x30, 0x2c, 0x4d, 0x6f, 0x63, 0x75, 0x74, 0x65, 0x20, 0x30, 0x35, 0x33, + 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x65, 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x62, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4d, 0x6f, 0x63, 0x75, 0x74, 0x65, 0x20, 0x30, 0x35, + 0x33, 0x58, 0x20, 0x4d, 0x35, 0x39, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x64, 0x34, + 0x66, 0x34, 0x33, 0x35, 0x35, 0x35, 0x34, 0x34, 0x35, 0x32, 0x64, 0x33, + 0x30, 0x33, 0x35, 0x33, 0x30, 0x35, 0x38, 0x30, 0x30, 0x2c, 0x4d, 0x6f, + 0x63, 0x75, 0x74, 0x65, 0x20, 0x30, 0x35, 0x34, 0x58, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x35, 0x38, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4d, 0x6f, 0x67, 0x61, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x61, 0x64, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x6f, 0x67, 0x61, 0x20, + 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x31, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x6f, 0x67, 0x61, 0x20, + 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x62, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x4f, 0x47, 0x41, 0x20, 0x58, 0x50, + 0x35, 0x41, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x61, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x4f, 0x47, + 0x41, 0x20, 0x58, 0x50, 0x35, 0x41, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x32, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x38, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4d, 0x4f, 0x47, 0x41, 0x20, 0x58, 0x50, 0x35, 0x58, 0x20, 0x50, + 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x36, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x50, 0x38, 0x38, 0x36, 0x36, 0x20, + 0x53, 0x75, 0x70, 0x65, 0x72, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x42, + 0x6f, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x65, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x53, 0x49, 0x20, 0x47, 0x43, 0x32, 0x30, + 0x20, 0x56, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x61, 0x63, + 0x6f, 0x6e, 0x20, 0x41, 0x73, 0x79, 0x6d, 0x6d, 0x65, 0x74, 0x72, 0x69, + 0x63, 0x20, 0x57, 0x69, 0x72, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x50, + 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x63, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, + 0x61, 0x63, 0x6f, 0x6e, 0x20, 0x47, 0x43, 0x20, 0x34, 0x30, 0x30, 0x45, + 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x35, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4e, 0x61, 0x63, 0x6f, 0x6e, 0x20, 0x47, 0x43, 0x2d, 0x31, 0x30, + 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, + 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, + 0x61, 0x74, 0x65, 0x63, 0x20, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, + 0x20, 0x50, 0x34, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x66, 0x31, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x65, 0x6f, 0x47, 0x65, 0x6f, 0x20, 0x50, + 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x39, 0x32, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x34, 0x37, 0x34, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4e, 0x65, 0x6f, 0x47, 0x65, 0x6f, 0x20, 0x58, 0x20, 0x41, 0x72, + 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x31, 0x38, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4e, 0x65, 0x78, 0x69, 0x6c, 0x75, 0x78, 0x20, 0x47, 0x61, 0x6d, + 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x45, 0x58, + 0x54, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x37, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, + 0x6f, 0x20, 0x33, 0x44, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, + 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x35, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x37, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x38, 0x30, + 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x47, + 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x34, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x7e, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, + 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, + 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, + 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x32, 0x7e, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x65, 0x36, 0x39, 0x36, 0x65, 0x37, 0x34, 0x36, + 0x35, 0x36, 0x65, 0x36, 0x34, 0x36, 0x66, 0x32, 0x30, 0x35, 0x33, 0x37, + 0x37, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, + 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6d, 0x62, + 0x69, 0x6e, 0x65, 0x64, 0x20, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, + 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, + 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x43, + 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x4a, 0x6f, 0x79, 0x2d, + 0x43, 0x6f, 0x6e, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, + 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, + 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, + 0x68, 0x20, 0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x4a, + 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x35, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x37, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, + 0x73, 0x63, 0x31, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x63, 0x36, 0x39, 0x36, 0x33, 0x32, 0x30, 0x35, 0x30, 0x37, 0x32, + 0x36, 0x66, 0x32, 0x30, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x30, 0x30, + 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, + 0x69, 0x74, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, + 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, + 0x69, 0x74, 0x63, 0x68, 0x20, 0x4c, 0x65, 0x66, 0x74, 0x20, 0x4a, 0x6f, + 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x36, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x30, 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x79, + 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x33, 0x61, 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, + 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, + 0x6f, 0x77, 0x65, 0x72, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x31, 0x61, 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, + 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, 0x6f, 0x77, 0x65, + 0x72, 0x41, 0x20, 0x43, 0x6f, 0x72, 0x65, 0x20, 0x50, 0x6c, 0x75, 0x73, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x38, 0x30, 0x33, 0x2c, 0x4e, + 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, + 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, + 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, + 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, + 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, + 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, + 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, + 0x31, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, + 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, + 0x63, 0x68, 0x20, 0x52, 0x69, 0x67, 0x68, 0x74, 0x20, 0x4a, 0x6f, 0x79, + 0x2d, 0x43, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x31, 0x7e, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x57, + 0x69, 0x69, 0x20, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, + 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x57, 0x69, 0x69, 0x20, 0x55, 0x20, + 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x38, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x6f, + 0x73, 0x74, 0x72, 0x6f, 0x6d, 0x6f, 0x20, 0x6e, 0x34, 0x35, 0x20, 0x44, + 0x75, 0x61, 0x6c, 0x20, 0x41, 0x6e, 0x61, 0x6c, 0x6f, 0x67, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x53, + 0x4f, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x62, 0x38, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x62, 0x37, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x32, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, + 0x63, 0x31, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x53, 0x4f, 0x20, 0x4e, 0x36, 0x34, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x2b, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x2b, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x38, 0x2c, 0x2d, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x39, 0x2c, 0x2d, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x37, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x53, + 0x4f, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x37, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x76, 0x30, 0x31, 0x2e, 0x30, + 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x37, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x76, 0x30, 0x31, 0x2e, 0x30, 0x34, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, + 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, + 0x59, 0x4b, 0x4f, 0x20, 0x43, 0x4f, 0x52, 0x45, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x31, + 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4f, 0x44, 0x52, 0x4f, + 0x49, 0x44, 0x20, 0x47, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x36, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4f, 0x44, + 0x52, 0x4f, 0x49, 0x44, 0x20, 0x47, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x64, 0x63, 0x32, + 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4f, 0x6e, 0x79, 0x78, 0x53, 0x6f, 0x66, 0x74, 0x20, 0x44, + 0x75, 0x61, 0x6c, 0x20, 0x4a, 0x6f, 0x79, 0x44, 0x69, 0x76, 0x69, 0x73, + 0x69, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x36, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4f, 0x55, 0x59, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x62, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, + 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4f, 0x55, 0x59, 0x41, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, + 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x32, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4f, 0x55, 0x59, 0x41, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x31, + 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x61, 0x64, 0x69, + 0x78, 0x20, 0x52, 0x6f, 0x63, 0x6b, 0x66, 0x69, 0x72, 0x65, 0x20, 0x50, + 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x42, + 0x72, 0x69, 0x64, 0x67, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x31, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x31, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x43, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, + 0x65, 0x30, 0x30, 0x30, 0x30, 0x62, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, + 0x50, 0x20, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, + 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, + 0x62, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, 0x20, 0x41, 0x66, 0x74, + 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, + 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x50, 0x44, 0x50, 0x20, 0x42, 0x61, 0x74, 0x74, 0x6c, 0x65, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x20, 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x37, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, 0x20, 0x42, 0x6c, 0x61, + 0x63, 0x6b, 0x20, 0x43, 0x61, 0x6d, 0x6f, 0x20, 0x57, 0x69, 0x72, 0x65, + 0x64, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, + 0x73, 0x20, 0x58, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, + 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, + 0x44, 0x50, 0x20, 0x45, 0x41, 0x20, 0x53, 0x70, 0x6f, 0x72, 0x74, 0x73, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, + 0x20, 0x46, 0x61, 0x63, 0x65, 0x6f, 0x66, 0x66, 0x20, 0x4e, 0x69, 0x6e, + 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, + 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, 0x20, 0x4b, 0x69, 0x6e, 0x67, 0x64, + 0x6f, 0x6d, 0x20, 0x48, 0x65, 0x61, 0x72, 0x74, 0x73, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, 0x20, 0x4e, 0x69, + 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, + 0x68, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x70, 0x61, 0x64, 0x20, 0x50, + 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x50, 0x44, 0x50, 0x20, 0x50, 0x53, 0x33, 0x20, 0x52, 0x6f, + 0x63, 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, + 0x20, 0x50, 0x53, 0x33, 0x20, 0x56, 0x65, 0x72, 0x73, 0x75, 0x73, 0x20, + 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x44, 0x50, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, + 0x30, 0x20, 0x56, 0x65, 0x72, 0x73, 0x75, 0x73, 0x20, 0x46, 0x69, 0x67, + 0x68, 0x74, 0x69, 0x6e, 0x67, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x61, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, + 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, + 0x30, 0x30, 0x30, 0x61, 0x37, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, 0x20, + 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x52, 0x61, 0x76, + 0x65, 0x6e, 0x20, 0x42, 0x6c, 0x61, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, 0x20, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x36, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x37, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x64, 0x61, 0x30, 0x63, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, + 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x39, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, 0x66, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, + 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, + 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x37, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, + 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x56, 0x69, 0x74, 0x61, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, + 0x65, 0x72, 0x41, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x33, 0x61, 0x35, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x41, 0x20, 0x31, 0x34, 0x32, 0x38, + 0x31, 0x32, 0x34, 0x2d, 0x30, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x41, 0x20, 0x46, + 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, + 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x35, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, + 0x6f, 0x77, 0x65, 0x72, 0x41, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, 0x50, + 0x72, 0x6f, 0x20, 0x45, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, + 0x63, 0x61, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x41, 0x20, 0x50, 0x72, + 0x6f, 0x20, 0x45, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x61, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x41, 0x20, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x41, 0x20, + 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, + 0x72, 0x41, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x61, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, + 0x72, 0x41, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, + 0x4d, 0x69, 0x6e, 0x69, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x41, 0x20, 0x58, 0x62, 0x6f, 0x78, + 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x53, 0x70, 0x65, 0x63, 0x74, 0x72, 0x61, + 0x20, 0x49, 0x6e, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, + 0x77, 0x65, 0x72, 0x41, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, + 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x64, 0x32, 0x63, 0x61, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, + 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x33, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, + 0x53, 0x32, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x34, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, + 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, + 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x38, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x62, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, + 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x66, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, + 0x37, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x79, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x31, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x79, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x30, 0x34, 0x63, 0x34, 0x31, 0x35, 0x39, 0x35, 0x33, 0x35, 0x34, + 0x34, 0x31, 0x35, 0x34, 0x34, 0x39, 0x34, 0x66, 0x34, 0x65, 0x30, 0x30, + 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x62, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, + 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x35, + 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x62, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, + 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x34, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x34, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x38, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x63, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x63, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, + 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, + 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x34, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x34, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x34, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, + 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x65, 0x36, + 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x74, 0x6f, 0x75, 0x63, 0x68, 0x70, 0x61, 0x64, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x65, + 0x36, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x38, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x66, 0x32, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x74, 0x6f, 0x75, 0x63, 0x68, 0x70, + 0x61, 0x64, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x65, 0x36, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x74, 0x6f, 0x75, + 0x63, 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x65, 0x36, 0x30, 0x63, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, + 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x66, 0x32, 0x30, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x74, 0x6f, 0x75, 0x63, 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, + 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, 0x62, 0x61, 0x20, 0x41, 0x72, 0x63, + 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, + 0x32, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, + 0x61, 0x6e, 0x62, 0x61, 0x20, 0x44, 0x72, 0x61, 0x67, 0x6f, 0x6e, 0x20, + 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x20, 0x28, 0x50, 0x53, 0x33, 0x29, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, 0x63, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, + 0x62, 0x61, 0x20, 0x44, 0x72, 0x61, 0x67, 0x6f, 0x6e, 0x20, 0x41, 0x72, + 0x63, 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x20, 0x28, 0x50, 0x53, 0x34, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, 0x63, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, 0x62, 0x61, + 0x20, 0x44, 0x72, 0x6f, 0x6e, 0x65, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, + 0x65, 0x20, 0x50, 0x53, 0x34, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, + 0x62, 0x61, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, + 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, 0x63, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, 0x62, 0x61, 0x20, + 0x4f, 0x62, 0x73, 0x69, 0x64, 0x69, 0x61, 0x6e, 0x20, 0x41, 0x72, 0x63, + 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x20, 0x28, 0x50, 0x53, 0x33, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, 0x63, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, 0x62, 0x61, 0x20, + 0x4f, 0x62, 0x73, 0x69, 0x64, 0x69, 0x61, 0x6e, 0x20, 0x41, 0x72, 0x63, + 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x20, 0x28, 0x50, 0x53, 0x34, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, + 0x74, 0x20, 0x34, 0x6e, 0x65, 0x73, 0x34, 0x73, 0x6e, 0x65, 0x73, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, + 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, + 0x74, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x4e, 0x45, 0x53, 0x20, 0x41, + 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, + 0x65, 0x74, 0x20, 0x47, 0x43, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x4e, 0x36, + 0x34, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x38, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x47, 0x43, + 0x20, 0x61, 0x6e, 0x64, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x41, 0x64, 0x61, + 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, + 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, 0x31, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x64, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, + 0x65, 0x72, 0x20, 0x4f, 0x6e, 0x7a, 0x61, 0x20, 0x43, 0x6c, 0x61, 0x73, + 0x73, 0x69, 0x63, 0x20, 0x45, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x50, + 0x61, 0x6e, 0x74, 0x68, 0x65, 0x72, 0x61, 0x20, 0x50, 0x53, 0x33, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, + 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, + 0x61, 0x7a, 0x65, 0x72, 0x20, 0x50, 0x61, 0x6e, 0x74, 0x68, 0x65, 0x72, + 0x61, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x50, + 0x61, 0x6e, 0x74, 0x68, 0x65, 0x72, 0x61, 0x20, 0x50, 0x53, 0x34, 0x20, + 0x45, 0x76, 0x6f, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, + 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, + 0x69, 0x6a, 0x75, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, 0x69, + 0x6a, 0x75, 0x20, 0x4d, 0x6f, 0x62, 0x69, 0x6c, 0x65, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, + 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, + 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, 0x69, 0x6a, 0x75, 0x20, 0x54, + 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x45, 0x64, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, + 0x61, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x69, 0x67, + 0x68, 0x74, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x66, 0x65, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x53, + 0x61, 0x62, 0x65, 0x72, 0x74, 0x6f, 0x6f, 0x74, 0x68, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x35, 0x64, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, + 0x20, 0x53, 0x61, 0x62, 0x65, 0x72, 0x74, 0x6f, 0x6f, 0x74, 0x68, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x64, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, + 0x65, 0x72, 0x20, 0x53, 0x61, 0x62, 0x65, 0x72, 0x74, 0x6f, 0x6f, 0x74, + 0x68, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, + 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, + 0x61, 0x7a, 0x65, 0x72, 0x20, 0x53, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x36, 0x33, 0x61, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, + 0x65, 0x72, 0x20, 0x53, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, + 0x20, 0x57, 0x69, 0x6c, 0x64, 0x63, 0x61, 0x74, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x62, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x47, 0x61, 0x6d, 0x65, 0x20, 0x4a, + 0x6f, 0x79, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x31, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x39, 0x39, + 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x20, + 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, + 0x72, 0x6f, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x35, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x32, 0x36, 0x35, 0x37, 0x34, 0x37, 0x32, 0x36, 0x66, 0x35, 0x33, 0x37, + 0x34, 0x36, 0x66, 0x36, 0x65, 0x36, 0x35, 0x33, 0x32, 0x30, 0x30, 0x2c, + 0x52, 0x65, 0x74, 0x72, 0x6f, 0x53, 0x74, 0x6f, 0x6e, 0x65, 0x20, 0x32, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x55, 0x53, 0x42, + 0x20, 0x4e, 0x36, 0x34, 0x20, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x50, 0x6f, + 0x72, 0x74, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, + 0x38, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x39, + 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x61, 0x3a, 0x62, 0x37, 0x2c, 0x62, 0x3a, 0x62, 0x36, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x76, + 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x72, 0x6f, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x64, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, + 0x76, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x72, 0x6f, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, + 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x52, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, 0x63, + 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, 0x50, 0x53, 0x33, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, + 0x65, 0x30, 0x30, 0x30, 0x30, 0x38, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, + 0x63, 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, 0x53, 0x77, 0x69, + 0x74, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x66, 0x65, 0x66, + 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x52, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, + 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, 0x63, 0x6b, 0x20, 0x43, + 0x61, 0x6e, 0x64, 0x79, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, + 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, + 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x32, 0x33, 0x66, 0x36, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, + 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x43, 0x79, 0x62, 0x6f, 0x72, 0x67, + 0x20, 0x56, 0x31, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x31, 0x35, + 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, + 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, + 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x32, 0x32, 0x30, 0x2c, 0x61, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x63, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, + 0x65, 0x6b, 0x20, 0x50, 0x32, 0x35, 0x30, 0x30, 0x20, 0x46, 0x6f, 0x72, + 0x63, 0x65, 0x20, 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, 0x2c, 0x61, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, + 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, + 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x32, 0x39, 0x30, 0x30, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, + 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x66, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, + 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x33, 0x32, 0x30, 0x30, 0x20, + 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, + 0x65, 0x6b, 0x20, 0x50, 0x33, 0x38, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, + 0x74, 0x65, 0x6b, 0x20, 0x50, 0x38, 0x38, 0x30, 0x2c, 0x61, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x39, + 0x39, 0x30, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x41, 0x6e, 0x61, 0x6c, + 0x6f, 0x67, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x66, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, + 0x53, 0x32, 0x37, 0x30, 0x30, 0x20, 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, + 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x62, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x53, 0x61, 0x6d, 0x73, 0x75, 0x6e, 0x67, 0x20, 0x45, 0x49, 0x47, 0x50, + 0x32, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x38, 0x31, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, + 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, 0x47, 0x65, + 0x6e, 0x65, 0x73, 0x69, 0x73, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, 0x33, + 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x65, 0x67, + 0x61, 0x20, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, + 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, + 0x65, 0x67, 0x61, 0x20, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x61, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, 0x53, 0x61, + 0x74, 0x75, 0x72, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, + 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, + 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, + 0x46, 0x43, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, + 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x32, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x68, 0x61, + 0x6e, 0x57, 0x61, 0x6e, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x66, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x63, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x53, 0x68, 0x61, 0x6e, 0x77, 0x61, 0x6e, 0x20, 0x47, 0x69, + 0x6f, 0x74, 0x65, 0x63, 0x6b, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x32, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x37, 0x35, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x68, + 0x61, 0x6e, 0x77, 0x61, 0x6e, 0x20, 0x50, 0x53, 0x33, 0x20, 0x50, 0x43, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, + 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x53, 0x68, 0x61, 0x6e, 0x77, 0x61, 0x6e, 0x20, 0x50, 0x53, 0x33, 0x20, + 0x50, 0x43, 0x20, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x61, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x4c, 0x36, 0x35, 0x36, + 0x36, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, + 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x53, 0x6f, 0x6e, 0x79, 0x20, 0x44, 0x75, 0x61, 0x6c, + 0x53, 0x68, 0x6f, 0x63, 0x6b, 0x20, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x62, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x6f, 0x6e, 0x79, 0x20, + 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x50, 0x6f, 0x72, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x53, 0x6f, 0x6e, 0x79, 0x20, 0x50, 0x53, 0x32, 0x20, 0x70, + 0x61, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x53, 0x6d, 0x61, 0x72, + 0x74, 0x4a, 0x6f, 0x79, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x37, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x53, 0x70, 0x65, 0x65, 0x64, 0x6c, 0x69, 0x6e, 0x6b, 0x20, + 0x54, 0x6f, 0x72, 0x69, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x53, 0x70, 0x65, 0x65, 0x64, 0x4c, 0x69, 0x6e, 0x6b, + 0x20, 0x58, 0x65, 0x6f, 0x78, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x41, 0x6e, + 0x61, 0x6c, 0x6f, 0x67, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x31, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x53, 0x74, 0x61, 0x64, 0x69, 0x61, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x64, 0x31, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x61, 0x64, 0x69, 0x61, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, + 0x6d, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x2b, 0x61, 0x35, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, + 0x35, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, + 0x31, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, + 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, + 0x6d, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, + 0x62, 0x31, 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, + 0x79, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x32, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x32, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x62, 0x31, 0x39, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x32, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x37, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, + 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, + 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x66, 0x63, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, + 0x6d, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x70, + 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x70, + 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, 0x44, + 0x65, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x3a, 0x62, + 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x78, 0x3a, 0x62, 0x35, 0x2c, 0x79, 0x3a, 0x62, 0x36, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x31, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, 0x56, 0x69, 0x72, 0x74, 0x75, + 0x61, 0x6c, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x65, 0x36, 0x39, 0x36, + 0x64, 0x36, 0x32, 0x37, 0x35, 0x37, 0x33, 0x32, 0x62, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, + 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x4e, 0x69, 0x6d, 0x62, + 0x75, 0x73, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x37, + 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, + 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, + 0x74, 0x75, 0x73, 0x20, 0x44, 0x75, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x31, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x37, 0x35, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, + 0x72, 0x69, 0x65, 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, 0x74, 0x75, 0x73, + 0x20, 0x44, 0x75, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x31, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x62, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, + 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, 0x74, 0x75, 0x73, 0x20, 0x44, 0x75, + 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x33, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, + 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, + 0x65, 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, 0x74, 0x75, 0x73, 0x20, 0x58, + 0x4c, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x38, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x72, 0x65, + 0x65, 0x74, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x65, 0x72, 0x20, 0x49, + 0x56, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x20, 0x54, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x62, 0x30, 0x37, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x75, 0x6e, + 0x63, 0x6f, 0x6d, 0x20, 0x53, 0x46, 0x58, 0x20, 0x50, 0x6c, 0x75, 0x73, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x36, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x53, 0x75, 0x70, 0x65, 0x72, 0x20, 0x4a, 0x6f, 0x79, + 0x20, 0x42, 0x6f, 0x78, 0x20, 0x35, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x75, 0x70, 0x65, + 0x72, 0x20, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x50, 0x6f, 0x72, 0x74, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x35, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x5a, 0x4d, 0x59, 0x20, + 0x50, 0x6f, 0x77, 0x65, 0x72, 0x20, 0x33, 0x20, 0x54, 0x75, 0x72, 0x62, + 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x35, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x53, 0x5a, 0x4d, 0x59, 0x20, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x20, + 0x44, 0x53, 0x34, 0x20, 0x57, 0x69, 0x72, 0x65, 0x64, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x37, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x32, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x5a, 0x4d, 0x59, 0x20, 0x50, + 0x6f, 0x77, 0x65, 0x72, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x33, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x53, 0x5a, 0x4d, 0x59, 0x20, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x20, 0x50, + 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x62, 0x61, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x54, 0x65, 0x63, 0x68, 0x6e, 0x6f, 0x6c, 0x6f, 0x67, 0x79, + 0x20, 0x49, 0x6e, 0x6e, 0x6f, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x50, 0x53, 0x32, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x63, 0x31, 0x38, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x54, 0x47, 0x5a, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x35, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, + 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x44, 0x75, 0x61, 0x6c, + 0x20, 0x41, 0x6e, 0x61, 0x6c, 0x6f, 0x67, 0x20, 0x33, 0x2e, 0x32, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x62, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, + 0x72, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x41, 0x6e, 0x61, 0x6c, 0x6f, + 0x67, 0x20, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, + 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x54, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x32, 0x33, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, + 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x44, 0x75, 0x61, + 0x6c, 0x20, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x50, 0x6c, + 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x64, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, + 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x65, + 0x53, 0x77, 0x61, 0x70, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x35, 0x30, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, + 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x46, 0x69, 0x72, 0x65, + 0x73, 0x74, 0x6f, 0x72, 0x6d, 0x20, 0x44, 0x69, 0x67, 0x69, 0x74, 0x61, + 0x6c, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x62, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, + 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x46, + 0x69, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x6d, 0x20, 0x44, 0x75, 0x61, + 0x6c, 0x20, 0x41, 0x6e, 0x61, 0x6c, 0x6f, 0x67, 0x20, 0x32, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, + 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x46, 0x69, 0x72, 0x65, + 0x73, 0x74, 0x6f, 0x72, 0x6d, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x50, + 0x6f, 0x77, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, + 0x73, 0x74, 0x65, 0x72, 0x20, 0x46, 0x69, 0x72, 0x65, 0x73, 0x74, 0x6f, + 0x72, 0x6d, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x50, 0x6f, 0x77, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, + 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, + 0x74, 0x65, 0x72, 0x20, 0x47, 0x50, 0x20, 0x58, 0x49, 0x44, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, + 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x47, 0x50, 0x58, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x64, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, + 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x52, + 0x75, 0x6e, 0x20, 0x4e, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x20, 0x50, + 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x64, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, + 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, + 0x52, 0x75, 0x6e, 0x20, 0x4e, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x20, + 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x64, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, + 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x54, + 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x32, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, + 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x56, 0x69, 0x62, 0x72, 0x61, 0x74, + 0x69, 0x6e, 0x67, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x37, 0x31, 0x64, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x54, 0x6f, 0x6d, 0x65, 0x65, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, + 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x62, 0x64, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, + 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x54, 0x6f, 0x6d, 0x65, 0x65, 0x20, 0x53, 0x4e, 0x45, + 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, 0x31, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x63, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x6f, 0x6f, 0x64, + 0x6c, 0x65, 0x73, 0x20, 0x32, 0x30, 0x30, 0x38, 0x20, 0x43, 0x68, 0x69, + 0x6d, 0x70, 0x20, 0x50, 0x43, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, + 0x6f, 0x72, 0x69, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x39, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x54, 0x6f, 0x72, 0x69, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x30, 0x61, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x52, 0x42, + 0x6f, 0x74, 0x20, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x20, 0x4a, + 0x6f, 0x79, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x52, 0x42, 0x6f, 0x74, + 0x20, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x20, 0x4a, 0x6f, 0x79, + 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x36, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x52, 0x42, 0x6f, 0x74, 0x20, 0x56, + 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x20, 0x4a, 0x6f, 0x79, 0x70, 0x61, + 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x32, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, + 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x66, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x54, 0x52, 0x42, 0x6f, 0x74, 0x20, 0x56, 0x69, 0x72, + 0x74, 0x75, 0x61, 0x6c, 0x20, 0x4a, 0x6f, 0x79, 0x70, 0x61, 0x64, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x66, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x63, 0x35, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x54, 0x72, 0x75, 0x73, 0x74, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, + 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x54, 0x77, 0x69, 0x6e, 0x20, 0x50, 0x53, 0x32, 0x20, 0x41, + 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x39, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x36, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x6e, 0x69, 0x70, + 0x6c, 0x61, 0x79, 0x20, 0x55, 0x36, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x53, + 0x42, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, + 0x53, 0x42, 0x20, 0x67, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, + 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x55, 0x53, 0x42, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, + 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x61, + 0x31, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x61, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x56, 0x69, 0x63, 0x74, + 0x72, 0x69, 0x78, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x46, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x56, 0x69, 0x63, 0x74, 0x72, 0x69, 0x78, 0x20, 0x50, + 0x72, 0x6f, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, + 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x33, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x56, 0x52, 0x20, 0x42, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x34, 0x66, 0x34, 0x64, + 0x34, 0x64, 0x34, 0x31, 0x34, 0x65, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x56, 0x58, 0x20, 0x47, 0x61, + 0x6d, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, + 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x36, 0x32, + 0x36, 0x66, 0x37, 0x38, 0x32, 0x30, 0x33, 0x33, 0x33, 0x36, 0x33, 0x30, + 0x32, 0x30, 0x35, 0x37, 0x36, 0x39, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, + 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x30, 0x37, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x65, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, + 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x61, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x61, 0x31, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, + 0x65, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, + 0x20, 0x45, 0x61, 0x73, 0x79, 0x53, 0x4d, 0x58, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x61, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, + 0x36, 0x30, 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, + 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, + 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x38, 0x36, 0x32, 0x36, 0x66, 0x37, 0x38, 0x32, 0x30, 0x34, 0x37, 0x36, + 0x31, 0x36, 0x64, 0x36, 0x35, 0x37, 0x30, 0x36, 0x31, 0x30, 0x30, 0x2c, + 0x58, 0x62, 0x6f, 0x78, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x62, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x64, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, + 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x61, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x65, 0x61, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, + 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, + 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x65, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, + 0x65, 0x20, 0x45, 0x6c, 0x69, 0x74, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x30, 0x62, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x45, 0x6c, 0x69, + 0x74, 0x65, 0x20, 0x32, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, + 0x65, 0x20, 0x45, 0x6c, 0x69, 0x74, 0x65, 0x20, 0x53, 0x65, 0x72, 0x69, + 0x65, 0x73, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x65, 0x61, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x62, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, + 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, + 0x61, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, + 0x20, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x62, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x31, 0x32, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, + 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, + 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, + 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, + 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, + 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x39, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, + 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x32, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, + 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, + 0x31, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, + 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x62, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, + 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, + 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, + 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, + 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, + 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, + 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, + 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, + 0x62, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, + 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, + 0x31, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, + 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x35, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, + 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x37, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, + 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x32, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, + 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, + 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x62, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x58, 0x62, 0x6f, 0x78, 0x20, 0x57, 0x69, 0x72, 0x65, 0x6c, 0x65, 0x73, + 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, + 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x35, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, + 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x58, 0x45, 0x4f, 0x58, 0x20, 0x53, 0x4c, 0x36, 0x35, 0x35, + 0x36, 0x20, 0x42, 0x4b, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, 0x32, 0x37, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x34, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x32, 0x39, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x69, 0x61, 0x6f, 0x4d, 0x69, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x32, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, + 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x65, 0x31, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x58, 0x69, 0x6e, 0x4d, 0x6f, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, + 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x34, 0x2c, + 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, + 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x78, 0x69, 0x6e, 0x70, + 0x75, 0x74, 0x2c, 0x58, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x30, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, + 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x5a, 0x65, 0x72, 0x6f, 0x70, 0x6c, + 0x75, 0x73, 0x20, 0x50, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x30, 0x31, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x5a, 0x65, 0x72, 0x6f, 0x70, 0x6c, 0x75, + 0x73, 0x20, 0x50, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, + 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x0d, 0x0a, 0x23, 0x20, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x0d, 0x0a, 0x33, 0x38, 0x36, 0x35, + 0x33, 0x39, 0x36, 0x34, 0x36, 0x33, 0x33, 0x32, 0x33, 0x30, 0x36, 0x36, + 0x36, 0x34, 0x36, 0x33, 0x33, 0x34, 0x33, 0x33, 0x33, 0x34, 0x33, 0x31, + 0x33, 0x35, 0x33, 0x33, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, + 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x36, 0x36, 0x36, 0x36, 0x32, 0x36, 0x34, + 0x33, 0x31, 0x36, 0x36, 0x33, 0x30, 0x36, 0x35, 0x33, 0x39, 0x36, 0x35, + 0x36, 0x33, 0x36, 0x36, 0x33, 0x34, 0x33, 0x38, 0x36, 0x32, 0x33, 0x34, + 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, + 0x74, 0x65, 0x72, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x33, 0x38, 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, + 0x32, 0x30, 0x34, 0x31, 0x37, 0x32, 0x36, 0x33, 0x36, 0x31, 0x36, 0x34, + 0x36, 0x35, 0x32, 0x30, 0x35, 0x33, 0x37, 0x34, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, + 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x31, 0x33, 0x39, 0x33, + 0x39, 0x36, 0x32, 0x36, 0x34, 0x36, 0x34, 0x33, 0x34, 0x33, 0x39, 0x33, + 0x38, 0x33, 0x36, 0x33, 0x35, 0x36, 0x36, 0x33, 0x31, 0x36, 0x33, 0x36, + 0x31, 0x33, 0x32, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x41, + 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, + 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x34, 0x33, 0x32, 0x33, 0x31, 0x33, 0x39, + 0x33, 0x34, 0x36, 0x31, 0x33, 0x31, 0x33, 0x30, 0x36, 0x32, 0x33, 0x33, + 0x36, 0x33, 0x36, 0x35, 0x36, 0x32, 0x36, 0x36, 0x33, 0x37, 0x33, 0x38, + 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x41, 0x72, 0x63, 0x61, + 0x64, 0x65, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, + 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x36, 0x34, 0x36, 0x34, 0x33, 0x35, 0x36, 0x35, 0x33, 0x38, 0x36, 0x31, + 0x33, 0x36, 0x36, 0x31, 0x33, 0x32, 0x36, 0x35, 0x36, 0x36, 0x33, 0x32, + 0x33, 0x36, 0x36, 0x33, 0x36, 0x35, 0x36, 0x34, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, + 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, + 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x33, 0x33, + 0x31, 0x33, 0x34, 0x33, 0x33, 0x33, 0x35, 0x33, 0x35, 0x33, 0x39, 0x33, + 0x30, 0x36, 0x36, 0x33, 0x34, 0x36, 0x35, 0x36, 0x34, 0x33, 0x36, 0x33, + 0x35, 0x33, 0x34, 0x33, 0x32, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x44, 0x6f, 0x67, 0x62, 0x6f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x34, 0x32, 0x36, + 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, 0x34, 0x34, 0x36, + 0x66, 0x36, 0x37, 0x36, 0x32, 0x36, 0x66, 0x36, 0x65, 0x36, 0x35, 0x32, + 0x30, 0x34, 0x64, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x44, + 0x6f, 0x67, 0x62, 0x6f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x34, 0x33, 0x34, 0x33, + 0x34, 0x33, 0x39, 0x33, 0x37, 0x33, 0x32, 0x33, 0x36, 0x36, 0x32, 0x33, + 0x34, 0x36, 0x36, 0x33, 0x34, 0x33, 0x39, 0x33, 0x34, 0x33, 0x37, 0x36, + 0x32, 0x33, 0x33, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x46, + 0x43, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x34, 0x32, 0x36, + 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, 0x33, 0x38, 0x34, + 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, 0x34, + 0x63, 0x36, 0x39, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4c, + 0x69, 0x74, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x30, 0x36, + 0x34, 0x33, 0x33, 0x33, 0x32, 0x33, 0x37, 0x33, 0x36, 0x36, 0x33, 0x33, + 0x31, 0x33, 0x32, 0x36, 0x33, 0x33, 0x31, 0x36, 0x36, 0x33, 0x37, 0x33, + 0x35, 0x36, 0x36, 0x33, 0x31, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x33, 0x38, 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, + 0x66, 0x32, 0x30, 0x34, 0x63, 0x36, 0x39, 0x37, 0x34, 0x36, 0x35, 0x32, + 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, + 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x32, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x32, 0x36, 0x35, 0x36, 0x33, 0x33, + 0x31, 0x36, 0x32, 0x36, 0x34, 0x36, 0x31, 0x33, 0x36, 0x33, 0x36, 0x33, + 0x34, 0x36, 0x33, 0x33, 0x37, 0x33, 0x35, 0x33, 0x35, 0x33, 0x30, 0x33, + 0x32, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, + 0x65, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x33, + 0x39, 0x33, 0x39, 0x33, 0x36, 0x36, 0x31, 0x36, 0x34, 0x33, 0x36, 0x33, + 0x38, 0x33, 0x30, 0x36, 0x32, 0x36, 0x36, 0x36, 0x32, 0x33, 0x32, 0x36, + 0x35, 0x33, 0x33, 0x33, 0x38, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x53, 0x45, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x34, 0x32, 0x36, 0x39, 0x37, + 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, 0x34, 0x63, 0x36, 0x39, 0x37, + 0x34, 0x36, 0x35, 0x32, 0x30, 0x35, 0x33, 0x34, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, + 0x65, 0x20, 0x53, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x39, + 0x33, 0x35, 0x36, 0x34, 0x33, 0x30, 0x36, 0x31, 0x36, 0x35, 0x36, 0x32, + 0x33, 0x36, 0x36, 0x34, 0x36, 0x36, 0x36, 0x34, 0x36, 0x36, 0x33, 0x36, + 0x36, 0x34, 0x33, 0x34, 0x33, 0x35, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x53, 0x45, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, + 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, + 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, + 0x61, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x31, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, + 0x33, 0x66, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, + 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x32, + 0x33, 0x32, 0x33, 0x31, 0x36, 0x31, 0x33, 0x36, 0x33, 0x30, 0x33, 0x37, + 0x36, 0x32, 0x33, 0x36, 0x33, 0x37, 0x33, 0x32, 0x36, 0x34, 0x33, 0x38, + 0x36, 0x34, 0x33, 0x36, 0x33, 0x34, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, + 0x0d, 0x0a, 0x33, 0x33, 0x36, 0x35, 0x36, 0x32, 0x36, 0x36, 0x33, 0x35, + 0x33, 0x36, 0x33, 0x30, 0x36, 0x34, 0x33, 0x39, 0x36, 0x36, 0x36, 0x35, + 0x33, 0x32, 0x33, 0x38, 0x36, 0x34, 0x36, 0x32, 0x36, 0x34, 0x2c, 0x38, + 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, + 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, + 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, + 0x34, 0x64, 0x33, 0x33, 0x33, 0x30, 0x32, 0x30, 0x34, 0x64, 0x36, 0x66, + 0x36, 0x34, 0x36, 0x62, 0x36, 0x39, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, + 0x0d, 0x0a, 0x33, 0x39, 0x33, 0x36, 0x36, 0x36, 0x33, 0x30, 0x36, 0x36, + 0x33, 0x30, 0x36, 0x32, 0x33, 0x37, 0x33, 0x32, 0x33, 0x37, 0x36, 0x31, + 0x36, 0x35, 0x36, 0x36, 0x33, 0x35, 0x33, 0x34, 0x33, 0x37, 0x2c, 0x38, + 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x34, + 0x36, 0x35, 0x33, 0x35, 0x33, 0x33, 0x33, 0x31, 0x33, 0x35, 0x33, 0x37, + 0x33, 0x37, 0x33, 0x39, 0x33, 0x34, 0x33, 0x32, 0x33, 0x34, 0x33, 0x36, + 0x33, 0x34, 0x33, 0x35, 0x36, 0x33, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x36, 0x33, 0x35, 0x36, 0x34, 0x33, 0x38, + 0x33, 0x34, 0x36, 0x31, 0x33, 0x36, 0x33, 0x36, 0x36, 0x33, 0x33, 0x37, + 0x33, 0x38, 0x36, 0x34, 0x33, 0x37, 0x36, 0x35, 0x33, 0x39, 0x33, 0x34, + 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, + 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x36, 0x36, 0x33, 0x39, 0x33, 0x30, 0x36, 0x34, 0x33, 0x39, 0x33, + 0x31, 0x36, 0x32, 0x33, 0x30, 0x33, 0x37, 0x33, 0x32, 0x33, 0x35, 0x36, + 0x36, 0x36, 0x35, 0x36, 0x36, 0x36, 0x33, 0x36, 0x36, 0x2c, 0x38, 0x42, + 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x33, 0x36, 0x36, 0x33, + 0x34, 0x33, 0x31, 0x33, 0x32, 0x36, 0x31, 0x33, 0x34, 0x33, 0x33, 0x33, + 0x33, 0x36, 0x36, 0x33, 0x39, 0x33, 0x32, 0x33, 0x33, 0x36, 0x31, 0x36, + 0x36, 0x33, 0x33, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, + 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, + 0x34, 0x36, 0x66, 0x32, 0x30, 0x34, 0x65, 0x33, 0x33, 0x33, 0x30, 0x32, + 0x30, 0x34, 0x64, 0x36, 0x66, 0x36, 0x34, 0x36, 0x62, 0x36, 0x39, 0x2c, + 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x36, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, + 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, + 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, + 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, + 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x36, 0x35, 0x32, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x38, + 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, + 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, + 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, 0x53, 0x33, 0x30, + 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, + 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x32, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, + 0x53, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x33, + 0x31, 0x33, 0x34, 0x33, 0x33, 0x36, 0x34, 0x33, 0x31, 0x33, 0x31, 0x36, + 0x35, 0x36, 0x32, 0x36, 0x32, 0x33, 0x30, 0x36, 0x36, 0x33, 0x31, 0x33, + 0x37, 0x33, 0x31, 0x36, 0x36, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x50, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, + 0x33, 0x32, 0x36, 0x35, 0x33, 0x36, 0x36, 0x34, 0x33, 0x33, 0x33, 0x39, + 0x33, 0x35, 0x33, 0x38, 0x36, 0x35, 0x33, 0x32, 0x33, 0x30, 0x36, 0x33, + 0x36, 0x31, 0x36, 0x33, 0x33, 0x39, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x50, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, + 0x38, 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, + 0x30, 0x35, 0x30, 0x33, 0x33, 0x33, 0x30, 0x32, 0x30, 0x36, 0x33, 0x36, + 0x63, 0x36, 0x31, 0x37, 0x33, 0x37, 0x33, 0x2c, 0x38, 0x42, 0x69, 0x74, + 0x44, 0x6f, 0x20, 0x50, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x33, 0x35, 0x33, 0x37, 0x36, 0x36, 0x36, 0x34, 0x33, 0x34, 0x33, 0x31, + 0x36, 0x34, 0x33, 0x38, 0x36, 0x33, 0x33, 0x33, 0x36, 0x31, 0x36, 0x35, + 0x33, 0x35, 0x33, 0x33, 0x33, 0x34, 0x33, 0x34, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, + 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x34, + 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, 0x33, + 0x38, 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, + 0x30, 0x35, 0x30, 0x37, 0x32, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x33, 0x38, 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, + 0x32, 0x30, 0x35, 0x30, 0x37, 0x32, 0x36, 0x66, 0x32, 0x30, 0x33, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x36, 0x32, 0x33, 0x37, 0x33, 0x37, 0x33, 0x39, 0x33, + 0x36, 0x36, 0x35, 0x33, 0x37, 0x33, 0x36, 0x33, 0x31, 0x36, 0x36, 0x33, + 0x32, 0x36, 0x32, 0x33, 0x38, 0x36, 0x35, 0x33, 0x34, 0x36, 0x33, 0x2c, + 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x33, 0x38, 0x33, 0x38, 0x36, 0x34, 0x36, 0x34, 0x36, 0x31, 0x33, + 0x30, 0x33, 0x34, 0x33, 0x32, 0x36, 0x34, 0x33, 0x35, 0x36, 0x32, 0x36, + 0x31, 0x33, 0x30, 0x33, 0x39, 0x36, 0x35, 0x36, 0x35, 0x2c, 0x38, 0x42, + 0x69, 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x34, 0x32, + 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, 0x33, 0x38, + 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, + 0x35, 0x32, 0x36, 0x35, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, + 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, + 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x36, 0x36, 0x33, 0x30, 0x33, 0x32, 0x33, 0x30, 0x33, + 0x34, 0x33, 0x30, 0x33, 0x38, 0x36, 0x31, 0x33, 0x33, 0x36, 0x35, 0x36, + 0x32, 0x33, 0x39, 0x36, 0x34, 0x33, 0x39, 0x33, 0x37, 0x36, 0x36, 0x2c, + 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, + 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, + 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, + 0x35, 0x33, 0x33, 0x33, 0x33, 0x30, 0x32, 0x30, 0x34, 0x64, 0x36, 0x66, + 0x36, 0x34, 0x36, 0x62, 0x36, 0x39, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x36, 0x36, 0x33, 0x31, 0x36, 0x34, 0x36, 0x32, 0x33, 0x35, 0x33, 0x35, + 0x36, 0x31, 0x33, 0x37, 0x36, 0x33, 0x33, 0x30, 0x33, 0x34, 0x36, 0x34, + 0x36, 0x32, 0x33, 0x31, 0x36, 0x31, 0x33, 0x37, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, + 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, + 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x38, + 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, 0x33, 0x30, 0x20, 0x50, + 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, + 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, + 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, + 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x34, 0x32, + 0x36, 0x39, 0x37, 0x34, 0x36, 0x34, 0x36, 0x66, 0x32, 0x30, 0x35, 0x33, + 0x34, 0x36, 0x33, 0x33, 0x33, 0x30, 0x32, 0x30, 0x35, 0x30, 0x37, 0x32, + 0x36, 0x66, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, + 0x53, 0x46, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, + 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x31, 0x36, 0x32, 0x33, 0x33, + 0x33, 0x34, 0x36, 0x33, 0x36, 0x33, 0x33, 0x38, 0x36, 0x34, 0x33, 0x32, + 0x33, 0x33, 0x33, 0x38, 0x33, 0x37, 0x33, 0x35, 0x33, 0x32, 0x36, 0x34, + 0x33, 0x39, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, + 0x43, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x33, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, + 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, + 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, + 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, + 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x32, 0x38, + 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, + 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, + 0x0d, 0x0a, 0x33, 0x38, 0x33, 0x31, 0x36, 0x32, 0x33, 0x30, 0x36, 0x31, + 0x33, 0x39, 0x33, 0x31, 0x36, 0x31, 0x33, 0x39, 0x36, 0x34, 0x33, 0x35, + 0x36, 0x36, 0x36, 0x36, 0x33, 0x35, 0x33, 0x38, 0x33, 0x39, 0x2c, 0x38, + 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x34, 0x32, 0x36, + 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, 0x35, 0x33, 0x34, + 0x65, 0x33, 0x33, 0x33, 0x30, 0x32, 0x30, 0x34, 0x64, 0x36, 0x66, 0x36, + 0x34, 0x36, 0x62, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, + 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, + 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x36, 0x35, 0x33, 0x32, 0x33, 0x35, 0x36, 0x33, 0x33, 0x30, 0x33, 0x32, + 0x33, 0x31, 0x36, 0x34, 0x36, 0x35, 0x33, 0x31, 0x33, 0x38, 0x33, 0x31, + 0x36, 0x32, 0x36, 0x34, 0x36, 0x33, 0x33, 0x35, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x35, 0x33, 0x38, 0x33, 0x35, 0x33, + 0x31, 0x33, 0x34, 0x36, 0x32, 0x36, 0x33, 0x36, 0x35, 0x33, 0x33, 0x33, + 0x30, 0x33, 0x30, 0x36, 0x32, 0x33, 0x38, 0x33, 0x35, 0x33, 0x31, 0x33, + 0x31, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, + 0x30, 0x20, 0x50, 0x50, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, + 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, + 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, + 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, + 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x66, 0x66, 0x66, 0x66, 0x30, 0x66, 0x30, 0x30, 0x2c, 0x38, 0x42, + 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, + 0x6f, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x36, 0x36, 0x35, + 0x33, 0x36, 0x33, 0x38, 0x36, 0x35, 0x36, 0x36, 0x33, 0x32, 0x33, 0x32, + 0x36, 0x32, 0x33, 0x35, 0x33, 0x34, 0x36, 0x32, 0x36, 0x34, 0x36, 0x36, + 0x33, 0x36, 0x36, 0x31, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, + 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, 0x6c, 0x75, + 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, + 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x33, 0x38, 0x33, 0x30, 0x33, 0x32, 0x33, 0x32, 0x33, 0x39, 0x33, 0x31, + 0x33, 0x33, 0x33, 0x38, 0x33, 0x38, 0x33, 0x36, 0x33, 0x36, 0x36, 0x33, + 0x33, 0x30, 0x33, 0x34, 0x36, 0x34, 0x36, 0x32, 0x2c, 0x38, 0x42, 0x69, + 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, + 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, + 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x33, 0x34, 0x36, 0x36, 0x33, 0x30, 0x33, + 0x34, 0x36, 0x31, 0x33, 0x35, 0x33, 0x36, 0x33, 0x33, 0x33, 0x35, 0x33, + 0x36, 0x36, 0x32, 0x36, 0x35, 0x36, 0x35, 0x36, 0x36, 0x36, 0x36, 0x2c, + 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, + 0x50, 0x72, 0x6f, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x34, 0x32, 0x36, 0x39, 0x37, + 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, 0x35, 0x33, 0x34, 0x65, 0x33, + 0x33, 0x33, 0x30, 0x32, 0x30, 0x35, 0x30, 0x37, 0x32, 0x36, 0x66, 0x32, + 0x62, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, + 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x31, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, + 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, + 0x39, 0x32, 0x30, 0x34, 0x33, 0x36, 0x66, 0x36, 0x64, 0x37, 0x30, 0x37, + 0x35, 0x37, 0x34, 0x36, 0x35, 0x37, 0x32, 0x32, 0x30, 0x34, 0x35, 0x36, + 0x65, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, + 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, + 0x0d, 0x0a, 0x36, 0x36, 0x33, 0x30, 0x36, 0x33, 0x33, 0x31, 0x36, 0x34, + 0x33, 0x35, 0x33, 0x31, 0x33, 0x33, 0x33, 0x32, 0x33, 0x30, 0x33, 0x30, + 0x36, 0x34, 0x33, 0x37, 0x33, 0x35, 0x33, 0x39, 0x33, 0x36, 0x2c, 0x38, + 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, + 0x72, 0x6f, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x32, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, + 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x45, 0x53, + 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x61, 0x62, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x30, 0x66, 0x30, 0x30, + 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x45, 0x53, + 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x33, 0x30, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x33, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x79, 0x3a, + 0x62, 0x32, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, + 0x33, 0x36, 0x36, 0x36, 0x36, 0x36, 0x33, 0x33, 0x31, 0x36, 0x31, 0x36, + 0x34, 0x36, 0x35, 0x33, 0x39, 0x33, 0x37, 0x33, 0x32, 0x36, 0x32, 0x33, + 0x37, 0x36, 0x31, 0x33, 0x33, 0x33, 0x31, 0x2c, 0x38, 0x42, 0x69, 0x74, + 0x44, 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, + 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, + 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x36, 0x34, 0x36, 0x66, 0x32, 0x30, + 0x35, 0x61, 0x36, 0x35, 0x37, 0x32, 0x36, 0x66, 0x32, 0x30, 0x34, 0x37, + 0x36, 0x31, 0x36, 0x64, 0x36, 0x35, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, + 0x30, 0x31, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, + 0x66, 0x30, 0x66, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, + 0x30, 0x33, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, + 0x66, 0x30, 0x66, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x33, 0x36, + 0x36, 0x33, 0x34, 0x33, 0x34, 0x33, 0x39, 0x33, 0x33, 0x36, 0x32, 0x33, + 0x30, 0x33, 0x30, 0x33, 0x33, 0x36, 0x31, 0x36, 0x36, 0x33, 0x30, 0x33, + 0x34, 0x36, 0x33, 0x33, 0x37, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, + 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x34, + 0x36, 0x35, 0x36, 0x33, 0x33, 0x30, 0x36, 0x32, 0x36, 0x33, 0x36, 0x31, + 0x36, 0x36, 0x36, 0x34, 0x33, 0x38, 0x33, 0x32, 0x33, 0x32, 0x36, 0x36, + 0x36, 0x33, 0x33, 0x39, 0x36, 0x33, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, + 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x33, + 0x33, 0x39, 0x36, 0x36, 0x36, 0x36, 0x33, 0x38, 0x36, 0x35, 0x36, 0x34, + 0x33, 0x39, 0x33, 0x33, 0x33, 0x34, 0x33, 0x39, 0x33, 0x32, 0x33, 0x36, + 0x33, 0x38, 0x36, 0x36, 0x33, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, + 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x33, 0x36, + 0x33, 0x33, 0x34, 0x33, 0x35, 0x36, 0x32, 0x33, 0x32, 0x36, 0x33, 0x33, + 0x37, 0x33, 0x34, 0x36, 0x36, 0x33, 0x34, 0x33, 0x34, 0x36, 0x31, 0x36, + 0x34, 0x36, 0x34, 0x33, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, + 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x32, 0x33, 0x33, + 0x33, 0x36, 0x33, 0x34, 0x36, 0x31, 0x33, 0x37, 0x33, 0x35, 0x36, 0x31, + 0x36, 0x31, 0x36, 0x33, 0x33, 0x32, 0x36, 0x31, 0x36, 0x35, 0x33, 0x32, + 0x33, 0x37, 0x33, 0x31, 0x2c, 0x41, 0x6d, 0x61, 0x7a, 0x6f, 0x6e, 0x20, + 0x4c, 0x75, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x34, 0x31, 0x37, 0x33, 0x37, 0x34, 0x37, 0x32, 0x36, 0x66, 0x32, 0x30, + 0x36, 0x33, 0x36, 0x39, 0x37, 0x34, 0x37, 0x39, 0x32, 0x30, 0x36, 0x64, + 0x36, 0x39, 0x36, 0x65, 0x36, 0x39, 0x32, 0x30, 0x2c, 0x41, 0x73, 0x74, + 0x72, 0x6f, 0x20, 0x43, 0x69, 0x74, 0x79, 0x20, 0x4d, 0x69, 0x6e, 0x69, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, + 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x32, + 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x35, 0x36, + 0x34, 0x33, 0x32, 0x36, 0x33, 0x33, 0x31, 0x33, 0x32, 0x36, 0x34, 0x33, + 0x38, 0x36, 0x31, 0x33, 0x34, 0x33, 0x37, 0x36, 0x33, 0x36, 0x32, 0x33, + 0x36, 0x33, 0x34, 0x33, 0x35, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, 0x20, + 0x56, 0x43, 0x53, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x32, 0x33, 0x35, 0x33, 0x38, 0x33, + 0x31, 0x36, 0x34, 0x33, 0x35, 0x36, 0x36, 0x33, 0x30, 0x36, 0x35, 0x36, + 0x33, 0x36, 0x34, 0x33, 0x30, 0x36, 0x35, 0x33, 0x35, 0x36, 0x32, 0x33, + 0x39, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, 0x20, 0x56, 0x43, 0x53, 0x20, + 0x4d, 0x6f, 0x64, 0x65, 0x72, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x32, 0x33, 0x30, + 0x33, 0x31, 0x36, 0x35, 0x36, 0x32, 0x36, 0x31, 0x33, 0x38, 0x33, 0x34, + 0x33, 0x39, 0x36, 0x32, 0x33, 0x36, 0x33, 0x36, 0x36, 0x36, 0x33, 0x34, + 0x36, 0x31, 0x36, 0x35, 0x2c, 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x20, 0x4d, + 0x61, 0x72, 0x73, 0x20, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x33, 0x38, 0x33, 0x33, 0x33, + 0x37, 0x33, 0x34, 0x33, 0x35, 0x36, 0x34, 0x33, 0x36, 0x36, 0x31, 0x33, + 0x31, 0x33, 0x32, 0x33, 0x30, 0x36, 0x34, 0x36, 0x31, 0x33, 0x35, 0x36, + 0x31, 0x2c, 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x20, 0x4d, 0x61, 0x72, 0x73, + 0x20, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x33, 0x34, 0x33, 0x31, 0x33, 0x34, 0x33, 0x30, 0x33, + 0x34, 0x33, 0x31, 0x36, 0x31, 0x36, 0x35, 0x33, 0x36, 0x36, 0x35, 0x33, + 0x35, 0x33, 0x37, 0x33, 0x37, 0x33, 0x32, 0x33, 0x33, 0x36, 0x35, 0x2c, + 0x45, 0x6c, 0x65, 0x63, 0x6f, 0x6d, 0x20, 0x4a, 0x43, 0x2d, 0x57, 0x30, + 0x31, 0x55, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x31, + 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, + 0x0d, 0x0a, 0x34, 0x38, 0x37, 0x35, 0x36, 0x39, 0x34, 0x61, 0x36, 0x39, + 0x36, 0x31, 0x32, 0x30, 0x34, 0x61, 0x34, 0x33, 0x32, 0x64, 0x35, 0x37, + 0x33, 0x30, 0x33, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, + 0x6c, 0x65, 0x63, 0x6f, 0x6d, 0x20, 0x4a, 0x43, 0x2d, 0x57, 0x30, 0x31, + 0x55, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x31, 0x2c, + 0x79, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x33, 0x30, 0x33, 0x36, 0x33, 0x32, 0x33, 0x30, 0x36, 0x35, 0x33, + 0x36, 0x33, 0x35, 0x36, 0x33, 0x33, 0x38, 0x36, 0x33, 0x33, 0x36, 0x36, + 0x33, 0x33, 0x38, 0x36, 0x32, 0x33, 0x32, 0x36, 0x35, 0x2c, 0x45, 0x76, + 0x6f, 0x20, 0x56, 0x52, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x64, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x46, 0x6c, + 0x79, 0x64, 0x69, 0x67, 0x69, 0x20, 0x56, 0x61, 0x64, 0x65, 0x72, 0x20, + 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, + 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, + 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, + 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, + 0x47, 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x20, 0x47, 0x33, 0x77, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x33, 0x34, 0x33, 0x32, 0x33, 0x36, 0x36, 0x32, 0x36, 0x35, 0x33, + 0x33, 0x33, 0x33, 0x36, 0x33, 0x36, 0x33, 0x33, 0x30, 0x33, 0x30, 0x36, + 0x36, 0x33, 0x31, 0x33, 0x32, 0x36, 0x32, 0x33, 0x33, 0x2c, 0x47, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x20, 0x4e, 0x65, 0x78, 0x75, 0x73, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x35, 0x33, 0x38, 0x33, 0x36, 0x33, 0x33, + 0x33, 0x35, 0x33, 0x39, 0x33, 0x35, 0x33, 0x39, 0x36, 0x35, 0x33, 0x34, + 0x33, 0x39, 0x33, 0x32, 0x33, 0x30, 0x36, 0x31, 0x36, 0x35, 0x36, 0x34, + 0x2c, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x20, 0x53, 0x74, 0x61, 0x64, + 0x69, 0x61, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x65, 0x35, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x64, 0x66, 0x66, 0x66, + 0x33, 0x66, 0x30, 0x30, 0x2c, 0x47, 0x50, 0x44, 0x20, 0x58, 0x44, 0x20, + 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, + 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x64, 0x36, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x65, 0x35, + 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x64, 0x66, 0x66, 0x66, 0x33, 0x66, + 0x38, 0x30, 0x2c, 0x47, 0x50, 0x44, 0x20, 0x58, 0x44, 0x20, 0x50, 0x6c, + 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x36, 0x36, 0x33, 0x33, 0x30, 0x33, 0x30, + 0x36, 0x35, 0x36, 0x31, 0x33, 0x31, 0x36, 0x36, 0x33, 0x38, 0x33, 0x37, + 0x33, 0x39, 0x36, 0x35, 0x36, 0x32, 0x33, 0x32, 0x33, 0x39, 0x33, 0x35, + 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x42, 0x61, 0x74, 0x74, 0x6c, 0x65, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x35, 0x36, 0x32, 0x33, + 0x34, 0x36, 0x36, 0x33, 0x34, 0x33, 0x34, 0x33, 0x33, 0x36, 0x35, 0x33, + 0x37, 0x33, 0x39, 0x33, 0x34, 0x36, 0x34, 0x33, 0x34, 0x36, 0x33, 0x36, + 0x33, 0x33, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, + 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, + 0x64, 0x65, 0x72, 0x20, 0x33, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x34, 0x38, 0x34, 0x66, 0x35, 0x32, 0x34, 0x39, + 0x32, 0x30, 0x34, 0x33, 0x34, 0x66, 0x32, 0x65, 0x32, 0x63, 0x34, 0x63, + 0x35, 0x34, 0x34, 0x34, 0x32, 0x65, 0x32, 0x30, 0x33, 0x31, 0x33, 0x30, + 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, + 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, + 0x20, 0x33, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x34, 0x38, + 0x34, 0x66, 0x35, 0x32, 0x34, 0x39, 0x32, 0x30, 0x34, 0x33, 0x34, 0x66, + 0x32, 0x65, 0x32, 0x63, 0x34, 0x63, 0x35, 0x34, 0x34, 0x34, 0x32, 0x30, + 0x32, 0x30, 0x35, 0x30, 0x34, 0x31, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, + 0x47, 0x65, 0x6d, 0x20, 0x50, 0x61, 0x64, 0x20, 0x33, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x35, 0x36, 0x35, 0x36, + 0x34, 0x33, 0x36, 0x36, 0x34, 0x36, 0x36, 0x36, 0x31, 0x33, 0x31, 0x33, + 0x32, 0x33, 0x32, 0x36, 0x35, 0x36, 0x36, 0x36, 0x31, 0x36, 0x31, 0x36, + 0x31, 0x33, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, 0x43, 0x20, + 0x45, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, + 0x31, 0x33, 0x30, 0x33, 0x34, 0x33, 0x33, 0x33, 0x32, 0x36, 0x35, 0x36, + 0x32, 0x36, 0x33, 0x36, 0x34, 0x33, 0x31, 0x36, 0x35, 0x33, 0x35, 0x33, + 0x34, 0x36, 0x33, 0x36, 0x36, 0x33, 0x33, 0x2c, 0x48, 0x6f, 0x72, 0x69, + 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, + 0x20, 0x50, 0x72, 0x6f, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x33, 0x32, 0x36, 0x35, 0x36, 0x36, 0x36, 0x34, 0x33, 0x35, 0x33, + 0x39, 0x36, 0x34, 0x33, 0x39, 0x33, 0x35, 0x36, 0x31, 0x33, 0x36, 0x36, + 0x33, 0x36, 0x32, 0x33, 0x33, 0x33, 0x36, 0x33, 0x36, 0x2c, 0x48, 0x6f, + 0x72, 0x69, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x53, 0x70, + 0x6c, 0x69, 0x74, 0x20, 0x50, 0x61, 0x64, 0x20, 0x50, 0x72, 0x6f, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x33, 0x30, 0x33, 0x30, 0x36, 0x35, 0x33, 0x39, 0x33, + 0x35, 0x36, 0x32, 0x33, 0x38, 0x36, 0x35, 0x33, 0x36, 0x33, 0x37, 0x33, + 0x31, 0x33, 0x37, 0x33, 0x30, 0x36, 0x35, 0x36, 0x31, 0x33, 0x34, 0x2c, + 0x48, 0x4f, 0x52, 0x49, 0x50, 0x41, 0x44, 0x20, 0x53, 0x77, 0x69, 0x74, + 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, + 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x34, 0x38, 0x37, 0x39, 0x37, 0x30, 0x36, 0x35, 0x37, 0x32, 0x36, + 0x62, 0x36, 0x39, 0x36, 0x65, 0x32, 0x30, 0x35, 0x30, 0x36, 0x31, 0x36, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x79, + 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x41, 0x64, 0x6d, 0x69, 0x72, + 0x61, 0x6c, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x62, 0x36, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x62, 0x37, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x62, 0x31, 0x37, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x62, 0x35, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x36, 0x32, 0x33, 0x33, 0x33, 0x33, 0x33, 0x31, 0x33, 0x35, 0x33, + 0x31, 0x33, 0x31, 0x33, 0x35, 0x33, 0x30, 0x33, 0x34, 0x33, 0x38, 0x36, + 0x31, 0x33, 0x36, 0x36, 0x32, 0x36, 0x36, 0x33, 0x36, 0x2c, 0x48, 0x79, + 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x41, 0x64, 0x6d, 0x69, 0x72, + 0x61, 0x6c, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x62, 0x36, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x62, 0x37, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x62, 0x31, 0x37, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x62, 0x35, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x33, 0x31, 0x33, 0x30, 0x36, 0x36, 0x33, 0x35, 0x33, 0x36, 0x33, + 0x35, 0x36, 0x32, 0x36, 0x36, 0x33, 0x38, 0x33, 0x34, 0x36, 0x33, 0x33, + 0x37, 0x33, 0x39, 0x33, 0x39, 0x36, 0x33, 0x33, 0x33, 0x2c, 0x48, 0x79, + 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x41, + 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x35, 0x33, 0x36, 0x38, 0x36, 0x31, 0x36, 0x65, 0x35, 0x37, 0x36, + 0x31, 0x36, 0x65, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, + 0x30, 0x34, 0x38, 0x37, 0x39, 0x37, 0x30, 0x36, 0x35, 0x2c, 0x48, 0x79, + 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x41, + 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x66, 0x66, 0x65, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x69, 0x42, + 0x75, 0x66, 0x66, 0x61, 0x6c, 0x6f, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, + 0x0d, 0x0a, 0x36, 0x34, 0x33, 0x30, 0x36, 0x31, 0x33, 0x37, 0x33, 0x36, + 0x33, 0x32, 0x36, 0x31, 0x33, 0x39, 0x36, 0x32, 0x36, 0x36, 0x33, 0x35, + 0x33, 0x34, 0x33, 0x33, 0x33, 0x30, 0x33, 0x35, 0x33, 0x31, 0x2c, 0x49, + 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x20, 0x47, 0x6f, 0x50, 0x61, + 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x79, 0x3a, + 0x62, 0x32, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, + 0x33, 0x32, 0x65, 0x35, 0x34, 0x32, 0x65, 0x34, 0x34, 0x32, 0x65, 0x32, + 0x30, 0x34, 0x39, 0x36, 0x65, 0x37, 0x34, 0x36, 0x35, 0x37, 0x32, 0x36, + 0x31, 0x36, 0x33, 0x37, 0x34, 0x32, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, + 0x72, 0x41, 0x63, 0x74, 0x20, 0x48, 0x61, 0x6d, 0x6d, 0x65, 0x72, 0x48, + 0x65, 0x61, 0x64, 0x20, 0x46, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x33, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x33, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, + 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x33, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x32, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, + 0x35, 0x33, 0x34, 0x36, 0x35, 0x33, 0x35, 0x36, 0x33, 0x36, 0x33, 0x33, + 0x33, 0x36, 0x36, 0x33, 0x39, 0x33, 0x31, 0x36, 0x31, 0x33, 0x32, 0x36, + 0x34, 0x36, 0x34, 0x33, 0x31, 0x36, 0x34, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, + 0x43, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x32, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x33, 0x33, 0x33, 0x34, 0x36, 0x35, 0x36, 0x36, 0x36, + 0x34, 0x33, 0x30, 0x33, 0x39, 0x33, 0x34, 0x33, 0x36, 0x33, 0x30, 0x33, + 0x37, 0x36, 0x35, 0x36, 0x35, 0x33, 0x32, 0x36, 0x33, 0x33, 0x35, 0x2c, + 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x4c, 0x29, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, + 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x35, 0x33, + 0x31, 0x33, 0x35, 0x33, 0x31, 0x36, 0x31, 0x33, 0x34, 0x33, 0x35, 0x36, + 0x32, 0x33, 0x33, 0x36, 0x36, 0x33, 0x31, 0x33, 0x38, 0x33, 0x35, 0x33, + 0x32, 0x36, 0x32, 0x33, 0x38, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, + 0x6e, 0x20, 0x28, 0x4c, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x34, 0x61, 0x36, 0x66, 0x37, 0x39, 0x32, 0x64, 0x34, + 0x33, 0x36, 0x66, 0x36, 0x65, 0x32, 0x30, 0x32, 0x38, 0x34, 0x63, 0x32, + 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x4c, 0x29, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, + 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, + 0x38, 0x33, 0x38, 0x33, 0x36, 0x36, 0x35, 0x36, 0x33, 0x33, 0x30, 0x33, + 0x39, 0x33, 0x36, 0x33, 0x30, 0x36, 0x36, 0x33, 0x38, 0x33, 0x33, 0x33, + 0x34, 0x36, 0x35, 0x33, 0x34, 0x36, 0x35, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, + 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x52, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, + 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x39, 0x33, 0x36, 0x33, 0x35, 0x36, + 0x31, 0x36, 0x31, 0x33, 0x39, 0x33, 0x36, 0x33, 0x30, 0x33, 0x32, 0x33, + 0x37, 0x33, 0x33, 0x33, 0x35, 0x33, 0x37, 0x33, 0x38, 0x33, 0x39, 0x33, + 0x31, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x52, + 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, + 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x34, + 0x61, 0x36, 0x66, 0x37, 0x39, 0x32, 0x64, 0x34, 0x33, 0x36, 0x66, 0x36, + 0x65, 0x32, 0x30, 0x32, 0x38, 0x35, 0x32, 0x32, 0x39, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, + 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x52, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, + 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x39, 0x36, 0x35, 0x36, + 0x31, 0x33, 0x36, 0x33, 0x36, 0x33, 0x36, 0x33, 0x38, 0x33, 0x32, 0x33, + 0x30, 0x33, 0x36, 0x33, 0x30, 0x33, 0x38, 0x36, 0x35, 0x33, 0x32, 0x36, + 0x34, 0x36, 0x34, 0x2c, 0x4a, 0x59, 0x53, 0x20, 0x41, 0x61, 0x70, 0x74, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x36, 0x33, 0x33, 0x31, 0x36, 0x35, 0x36, 0x34, 0x33, 0x38, 0x33, + 0x35, 0x33, 0x39, 0x36, 0x36, 0x33, 0x31, 0x36, 0x36, 0x33, 0x35, 0x33, + 0x30, 0x33, 0x34, 0x36, 0x31, 0x36, 0x34, 0x33, 0x34, 0x2c, 0x4a, 0x59, + 0x53, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, + 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, + 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x34, 0x36, 0x32, 0x33, 0x31, + 0x36, 0x33, 0x33, 0x33, 0x33, 0x35, 0x36, 0x31, 0x36, 0x34, 0x33, 0x33, + 0x33, 0x39, 0x36, 0x32, 0x33, 0x32, 0x33, 0x35, 0x33, 0x37, 0x33, 0x32, + 0x33, 0x32, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, + 0x46, 0x33, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x35, + 0x36, 0x32, 0x33, 0x33, 0x36, 0x34, 0x33, 0x39, 0x33, 0x36, 0x36, 0x31, + 0x36, 0x32, 0x36, 0x32, 0x33, 0x31, 0x33, 0x34, 0x33, 0x38, 0x36, 0x36, + 0x36, 0x31, 0x33, 0x33, 0x33, 0x37, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, + 0x65, 0x63, 0x68, 0x20, 0x46, 0x37, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x34, 0x63, 0x36, 0x66, 0x36, 0x37, 0x36, 0x39, + 0x37, 0x34, 0x36, 0x35, 0x36, 0x33, 0x36, 0x38, 0x32, 0x30, 0x34, 0x37, + 0x36, 0x31, 0x36, 0x64, 0x36, 0x35, 0x37, 0x30, 0x36, 0x31, 0x36, 0x34, + 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, 0x37, + 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x34, 0x33, 0x39, + 0x36, 0x33, 0x33, 0x31, 0x33, 0x33, 0x33, 0x32, 0x33, 0x30, 0x33, 0x32, + 0x36, 0x33, 0x33, 0x33, 0x33, 0x31, 0x33, 0x33, 0x33, 0x30, 0x33, 0x33, + 0x36, 0x35, 0x33, 0x33, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, + 0x68, 0x20, 0x46, 0x37, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x33, 0x39, 0x36, 0x35, 0x33, 0x33, 0x36, 0x35, 0x33, 0x37, 0x33, 0x38, + 0x36, 0x34, 0x36, 0x33, 0x33, 0x39, 0x33, 0x35, 0x33, 0x38, 0x33, 0x32, + 0x33, 0x36, 0x33, 0x36, 0x33, 0x34, 0x33, 0x38, 0x2c, 0x4c, 0x6f, 0x67, + 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x47, 0x20, 0x43, 0x6c, 0x6f, 0x75, + 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x7e, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x7e, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x34, 0x31, 0x36, 0x64, 0x36, + 0x31, 0x37, 0x61, 0x36, 0x66, 0x36, 0x65, 0x32, 0x30, 0x34, 0x37, 0x36, + 0x31, 0x36, 0x64, 0x36, 0x35, 0x32, 0x30, 0x34, 0x33, 0x36, 0x66, 0x36, + 0x65, 0x37, 0x34, 0x2c, 0x4c, 0x75, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x34, + 0x63, 0x37, 0x35, 0x36, 0x65, 0x36, 0x31, 0x32, 0x30, 0x34, 0x37, 0x36, + 0x31, 0x36, 0x64, 0x36, 0x35, 0x37, 0x30, 0x36, 0x31, 0x36, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x75, 0x6e, 0x61, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x30, 0x33, 0x36, 0x33, 0x30, 0x36, + 0x36, 0x36, 0x32, 0x33, 0x35, 0x33, 0x39, 0x33, 0x32, 0x33, 0x35, 0x33, + 0x34, 0x33, 0x36, 0x33, 0x36, 0x33, 0x39, 0x33, 0x32, 0x33, 0x33, 0x36, + 0x33, 0x2c, 0x4d, 0x61, 0x67, 0x69, 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x31, 0x33, + 0x35, 0x33, 0x37, 0x36, 0x32, 0x33, 0x39, 0x33, 0x39, 0x33, 0x35, 0x33, + 0x38, 0x36, 0x36, 0x36, 0x32, 0x33, 0x33, 0x36, 0x33, 0x36, 0x35, 0x36, + 0x32, 0x36, 0x33, 0x33, 0x34, 0x2c, 0x4d, 0x61, 0x67, 0x69, 0x63, 0x20, + 0x4e, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x33, 0x39, 0x36, 0x32, 0x33, 0x35, 0x36, 0x35, 0x33, 0x34, 0x36, + 0x33, 0x36, 0x36, 0x36, 0x32, 0x33, 0x39, 0x33, 0x31, 0x36, 0x36, 0x36, + 0x36, 0x33, 0x33, 0x33, 0x32, 0x33, 0x35, 0x33, 0x30, 0x2c, 0x4d, 0x61, + 0x67, 0x69, 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x36, 0x64, 0x36, 0x31, 0x37, 0x39, 0x36, 0x36, 0x36, + 0x63, 0x36, 0x31, 0x37, 0x33, 0x36, 0x38, 0x32, 0x30, 0x36, 0x63, 0x36, + 0x39, 0x36, 0x64, 0x36, 0x39, 0x37, 0x34, 0x36, 0x35, 0x36, 0x34, 0x2c, + 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x47, 0x61, 0x6d, + 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x79, 0x3a, + 0x62, 0x32, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x34, + 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x66, 0x36, + 0x63, 0x36, 0x63, 0x36, 0x35, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, + 0x6c, 0x61, 0x73, 0x68, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x41, 0x64, 0x61, + 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x35, 0x36, 0x36, + 0x36, 0x33, 0x33, 0x30, 0x36, 0x33, 0x33, 0x38, 0x33, 0x38, 0x33, 0x38, + 0x33, 0x30, 0x36, 0x31, 0x33, 0x31, 0x33, 0x36, 0x33, 0x33, 0x33, 0x32, + 0x36, 0x34, 0x36, 0x31, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, + 0x68, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x39, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x37, 0x33, 0x31, 0x36, 0x35, 0x36, + 0x35, 0x33, 0x39, 0x36, 0x33, 0x36, 0x34, 0x33, 0x38, 0x36, 0x36, 0x33, + 0x35, 0x33, 0x38, 0x33, 0x32, 0x33, 0x30, 0x33, 0x35, 0x33, 0x33, 0x36, + 0x35, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x53, + 0x61, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x34, + 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, + 0x0d, 0x0a, 0x34, 0x38, 0x37, 0x35, 0x36, 0x39, 0x34, 0x61, 0x36, 0x39, + 0x36, 0x31, 0x32, 0x30, 0x32, 0x30, 0x35, 0x35, 0x35, 0x33, 0x34, 0x32, + 0x32, 0x30, 0x34, 0x37, 0x36, 0x31, 0x36, 0x64, 0x36, 0x35, 0x2c, 0x4d, + 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x53, 0x61, 0x74, 0x75, + 0x72, 0x6e, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x32, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x79, 0x3a, + 0x62, 0x32, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, + 0x33, 0x35, 0x61, 0x34, 0x64, 0x37, 0x39, 0x32, 0x64, 0x37, 0x30, 0x36, + 0x66, 0x37, 0x37, 0x36, 0x35, 0x37, 0x32, 0x32, 0x30, 0x34, 0x63, 0x35, + 0x34, 0x34, 0x34, 0x32, 0x30, 0x34, 0x33, 0x2c, 0x4d, 0x61, 0x79, 0x66, + 0x6c, 0x61, 0x73, 0x68, 0x20, 0x57, 0x69, 0x69, 0x20, 0x43, 0x6c, 0x61, + 0x73, 0x73, 0x69, 0x63, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x33, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x79, 0x3a, 0x62, + 0x32, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x30, + 0x36, 0x35, 0x33, 0x39, 0x36, 0x32, 0x36, 0x34, 0x33, 0x36, 0x36, 0x36, + 0x33, 0x30, 0x33, 0x36, 0x33, 0x31, 0x33, 0x37, 0x36, 0x34, 0x33, 0x38, + 0x33, 0x37, 0x33, 0x35, 0x33, 0x32, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, + 0x61, 0x73, 0x68, 0x20, 0x57, 0x69, 0x69, 0x20, 0x44, 0x6f, 0x6c, 0x70, + 0x68, 0x69, 0x6e, 0x42, 0x61, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x33, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x32, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x33, 0x39, 0x33, 0x34, 0x36, 0x31, 0x33, 0x31, 0x33, + 0x39, 0x36, 0x32, 0x33, 0x33, 0x33, 0x37, 0x36, 0x35, 0x33, 0x35, 0x33, + 0x39, 0x33, 0x36, 0x36, 0x35, 0x33, 0x36, 0x33, 0x31, 0x36, 0x31, 0x2c, + 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x57, 0x69, 0x69, + 0x20, 0x55, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x33, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x79, + 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x33, 0x31, 0x33, 0x32, 0x33, 0x35, 0x36, 0x34, 0x36, 0x36, 0x33, 0x38, + 0x36, 0x32, 0x36, 0x33, 0x33, 0x32, 0x33, 0x34, 0x36, 0x34, 0x36, 0x33, + 0x33, 0x30, 0x33, 0x37, 0x33, 0x31, 0x33, 0x38, 0x2c, 0x4d, 0x65, 0x67, + 0x61, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, + 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x30, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x31, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x37, 0x33, 0x33, 0x33, + 0x35, 0x36, 0x34, 0x33, 0x39, 0x33, 0x32, 0x36, 0x31, 0x36, 0x35, 0x33, + 0x37, 0x33, 0x35, 0x33, 0x30, 0x36, 0x31, 0x33, 0x32, 0x36, 0x31, 0x33, + 0x30, 0x36, 0x31, 0x2c, 0x4d, 0x65, 0x67, 0x61, 0x20, 0x44, 0x72, 0x69, + 0x76, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x32, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x36, 0x34, 0x33, 0x36, 0x33, 0x33, 0x36, 0x33, 0x33, + 0x33, 0x36, 0x36, 0x33, 0x33, 0x33, 0x36, 0x33, 0x37, 0x33, 0x36, 0x33, + 0x39, 0x33, 0x30, 0x33, 0x38, 0x33, 0x31, 0x33, 0x34, 0x36, 0x34, 0x2c, + 0x4d, 0x65, 0x67, 0x61, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x33, + 0x33, 0x32, 0x33, 0x37, 0x36, 0x33, 0x33, 0x32, 0x33, 0x31, 0x33, 0x32, + 0x33, 0x37, 0x36, 0x35, 0x33, 0x37, 0x33, 0x37, 0x36, 0x32, 0x36, 0x36, + 0x33, 0x39, 0x33, 0x33, 0x36, 0x36, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, + 0x73, 0x6f, 0x66, 0x74, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x53, 0x74, + 0x72, 0x69, 0x6b, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, + 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x37, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x7e, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, + 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x30, 0x33, 0x30, 0x36, 0x34, + 0x36, 0x31, 0x36, 0x31, 0x33, 0x38, 0x33, 0x34, 0x33, 0x33, 0x33, 0x34, + 0x33, 0x39, 0x33, 0x30, 0x33, 0x37, 0x33, 0x34, 0x33, 0x31, 0x36, 0x35, + 0x33, 0x39, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, + 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x20, + 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x32, 0x33, 0x38, 0x36, + 0x32, 0x33, 0x35, 0x33, 0x35, 0x33, 0x36, 0x33, 0x30, 0x33, 0x39, 0x33, + 0x30, 0x33, 0x33, 0x33, 0x39, 0x33, 0x31, 0x33, 0x35, 0x36, 0x31, 0x33, + 0x38, 0x33, 0x31, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, + 0x74, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, + 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x34, 0x64, 0x34, 0x66, 0x34, 0x33, 0x35, 0x35, 0x35, + 0x34, 0x34, 0x35, 0x32, 0x64, 0x33, 0x30, 0x33, 0x35, 0x33, 0x33, 0x35, + 0x38, 0x32, 0x64, 0x34, 0x64, 0x33, 0x35, 0x33, 0x31, 0x32, 0x64, 0x2c, + 0x4d, 0x6f, 0x63, 0x75, 0x74, 0x65, 0x20, 0x30, 0x35, 0x33, 0x58, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x33, 0x33, 0x33, 0x34, 0x33, 0x33, 0x36, 0x31, 0x33, + 0x37, 0x36, 0x31, 0x36, 0x33, 0x36, 0x32, 0x33, 0x34, 0x33, 0x38, 0x36, + 0x31, 0x33, 0x34, 0x36, 0x36, 0x36, 0x31, 0x36, 0x35, 0x33, 0x31, 0x2c, + 0x4d, 0x6f, 0x63, 0x75, 0x74, 0x65, 0x20, 0x4d, 0x30, 0x35, 0x33, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x39, 0x33, 0x30, + 0x36, 0x36, 0x33, 0x35, 0x36, 0x36, 0x33, 0x30, 0x36, 0x31, 0x36, 0x33, + 0x36, 0x35, 0x36, 0x33, 0x33, 0x31, 0x36, 0x31, 0x36, 0x36, 0x33, 0x30, + 0x33, 0x39, 0x36, 0x36, 0x2c, 0x4d, 0x6f, 0x63, 0x75, 0x74, 0x65, 0x20, + 0x4d, 0x30, 0x35, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x37, 0x35, 0x37, 0x33, 0x36, 0x32, 0x32, 0x30, 0x36, 0x37, 0x36, + 0x31, 0x36, 0x64, 0x36, 0x35, 0x37, 0x30, 0x36, 0x31, 0x36, 0x34, 0x32, + 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x2c, 0x4e, 0x45, + 0x58, 0x54, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, + 0x66, 0x66, 0x66, 0x30, 0x66, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, + 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, + 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x34, 0x33, 0x32, 0x33, 0x34, 0x33, + 0x37, 0x33, 0x39, 0x36, 0x35, 0x33, 0x34, 0x36, 0x34, 0x33, 0x35, 0x33, + 0x31, 0x33, 0x32, 0x36, 0x31, 0x36, 0x31, 0x36, 0x33, 0x33, 0x37, 0x33, + 0x38, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, + 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, + 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6d, 0x69, 0x73, 0x63, + 0x31, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x30, 0x37, 0x32, 0x36, 0x66, 0x32, 0x30, + 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x66, + 0x36, 0x63, 0x36, 0x63, 0x36, 0x35, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, + 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x36, 0x33, 0x32, 0x36, + 0x35, 0x33, 0x33, 0x33, 0x35, 0x33, 0x31, 0x36, 0x36, 0x33, 0x32, 0x33, + 0x39, 0x36, 0x35, 0x36, 0x32, 0x33, 0x36, 0x36, 0x31, 0x33, 0x30, 0x33, + 0x39, 0x33, 0x33, 0x2c, 0x4e, 0x53, 0x4f, 0x20, 0x4e, 0x36, 0x34, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x2b, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x2b, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x2d, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x2d, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, + 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x34, 0x65, 0x33, 0x36, 0x33, 0x34, + 0x32, 0x30, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, + 0x36, 0x66, 0x36, 0x63, 0x36, 0x63, 0x36, 0x35, 0x37, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x4e, 0x53, 0x4f, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x2b, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x2b, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x2d, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x2d, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x33, 0x34, 0x65, 0x34, 0x35, 0x35, + 0x33, 0x32, 0x30, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, + 0x32, 0x36, 0x66, 0x36, 0x63, 0x36, 0x63, 0x36, 0x35, 0x37, 0x32, 0x30, + 0x30, 0x2c, 0x4e, 0x53, 0x4f, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, + 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, + 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, + 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x34, 0x36, 0x32, 0x33, 0x38, + 0x36, 0x33, 0x33, 0x34, 0x36, 0x31, 0x33, 0x33, 0x36, 0x33, 0x33, 0x35, + 0x36, 0x31, 0x36, 0x32, 0x36, 0x31, 0x33, 0x36, 0x33, 0x36, 0x36, 0x36, + 0x33, 0x34, 0x2c, 0x4e, 0x53, 0x4f, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, + 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x63, 0x66, 0x37, 0x66, 0x33, + 0x66, 0x30, 0x30, 0x2c, 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x37, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, + 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, 0x39, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x34, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x64, + 0x66, 0x37, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x4e, 0x56, 0x49, 0x44, + 0x49, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x37, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x66, 0x37, 0x66, 0x33, 0x66, 0x38, 0x30, 0x2c, + 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x37, 0x33, 0x33, 0x36, + 0x34, 0x33, 0x35, 0x36, 0x36, 0x36, 0x33, 0x33, 0x38, 0x36, 0x35, 0x33, + 0x35, 0x36, 0x35, 0x33, 0x31, 0x33, 0x37, 0x33, 0x31, 0x33, 0x30, 0x33, + 0x38, 0x33, 0x34, 0x2c, 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x34, 0x65, 0x35, 0x36, 0x34, + 0x39, 0x34, 0x34, 0x34, 0x39, 0x34, 0x31, 0x32, 0x30, 0x34, 0x33, 0x36, + 0x66, 0x37, 0x32, 0x37, 0x30, 0x36, 0x66, 0x37, 0x32, 0x36, 0x31, 0x37, + 0x34, 0x36, 0x39, 0x2c, 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x31, 0x33, 0x36, 0x33, + 0x39, 0x33, 0x31, 0x36, 0x35, 0x36, 0x31, 0x33, 0x35, 0x33, 0x33, 0x36, + 0x31, 0x33, 0x30, 0x36, 0x36, 0x33, 0x35, 0x36, 0x31, 0x36, 0x31, 0x36, + 0x32, 0x36, 0x34, 0x2c, 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x39, 0x33, 0x38, 0x33, + 0x33, 0x33, 0x35, 0x33, 0x31, 0x33, 0x34, 0x33, 0x38, 0x36, 0x32, 0x33, + 0x34, 0x33, 0x39, 0x33, 0x37, 0x33, 0x35, 0x33, 0x38, 0x33, 0x34, 0x33, + 0x32, 0x36, 0x36, 0x2c, 0x4f, 0x55, 0x59, 0x41, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, + 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x34, 0x66, 0x35, 0x35, 0x35, 0x39, + 0x34, 0x31, 0x32, 0x30, 0x34, 0x37, 0x36, 0x31, 0x36, 0x64, 0x36, 0x35, + 0x32, 0x30, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, + 0x36, 0x66, 0x2c, 0x4f, 0x55, 0x59, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x62, 0x31, 0x38, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x78, 0x3a, + 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x30, 0x36, 0x35, 0x37, 0x32, 0x36, 0x36, + 0x36, 0x66, 0x37, 0x32, 0x36, 0x64, 0x36, 0x31, 0x36, 0x65, 0x36, 0x33, + 0x36, 0x35, 0x32, 0x30, 0x34, 0x34, 0x36, 0x35, 0x37, 0x33, 0x36, 0x39, + 0x2c, 0x50, 0x44, 0x50, 0x20, 0x50, 0x53, 0x33, 0x20, 0x52, 0x6f, 0x63, + 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x32, 0x36, 0x35, 0x33, 0x33, 0x33, + 0x35, 0x33, 0x32, 0x36, 0x32, 0x36, 0x31, 0x33, 0x30, 0x33, 0x36, 0x36, + 0x33, 0x33, 0x35, 0x36, 0x32, 0x36, 0x33, 0x36, 0x32, 0x36, 0x33, 0x33, + 0x39, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x31, 0x39, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x33, 0x36, + 0x66, 0x36, 0x65, 0x37, 0x39, 0x32, 0x30, 0x34, 0x39, 0x36, 0x65, 0x37, + 0x34, 0x36, 0x35, 0x37, 0x32, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x36, + 0x39, 0x37, 0x36, 0x36, 0x35, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, + 0x73, 0x63, 0x31, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x37, 0x36, 0x39, 0x37, 0x32, 0x36, + 0x35, 0x36, 0x63, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x32, 0x30, 0x34, + 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x66, 0x36, + 0x63, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x31, 0x36, 0x35, 0x33, 0x39, 0x36, 0x32, + 0x33, 0x35, 0x33, 0x32, 0x33, 0x32, 0x33, 0x36, 0x36, 0x31, 0x33, 0x30, + 0x33, 0x32, 0x36, 0x35, 0x33, 0x30, 0x33, 0x36, 0x33, 0x30, 0x36, 0x31, + 0x2c, 0x50, 0x6f, 0x6b, 0x6b, 0x65, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x33, 0x32, 0x36, 0x36, 0x36, 0x36, 0x33, 0x33, 0x36, 0x36, 0x33, 0x37, + 0x33, 0x35, 0x33, 0x35, 0x33, 0x32, 0x33, 0x34, 0x33, 0x36, 0x33, 0x30, + 0x36, 0x34, 0x33, 0x38, 0x36, 0x31, 0x33, 0x32, 0x2c, 0x50, 0x53, 0x32, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, + 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x79, + 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x35, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x39, 0x32, 0x30, 0x35, + 0x30, 0x34, 0x63, 0x34, 0x31, 0x35, 0x39, 0x35, 0x33, 0x35, 0x34, 0x34, + 0x31, 0x35, 0x34, 0x34, 0x39, 0x34, 0x66, 0x34, 0x65, 0x2c, 0x50, 0x53, + 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x36, 0x31, 0x33, 0x36, 0x33, 0x30, 0x33, 0x34, 0x36, 0x36, 0x33, 0x38, + 0x33, 0x39, 0x33, 0x37, 0x36, 0x36, 0x33, 0x38, 0x36, 0x35, 0x33, 0x34, + 0x36, 0x33, 0x36, 0x33, 0x33, 0x38, 0x36, 0x35, 0x2c, 0x50, 0x53, 0x33, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x61, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x36, 0x33, 0x36, 0x36, 0x35, 0x33, 0x39, + 0x36, 0x35, 0x36, 0x35, 0x36, 0x34, 0x36, 0x35, 0x33, 0x34, 0x33, 0x32, + 0x33, 0x35, 0x33, 0x31, 0x33, 0x39, 0x33, 0x35, 0x36, 0x35, 0x33, 0x36, + 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x36, 0x33, 0x38, 0x33, 0x31, 0x33, + 0x32, 0x33, 0x32, 0x36, 0x31, 0x36, 0x34, 0x36, 0x32, 0x36, 0x36, 0x33, + 0x36, 0x33, 0x31, 0x33, 0x37, 0x33, 0x37, 0x33, 0x37, 0x33, 0x30, 0x33, + 0x37, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, + 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x34, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x33, 0x66, + 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x34, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x65, 0x33, 0x66, 0x30, 0x30, + 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, + 0x34, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x65, 0x33, + 0x66, 0x38, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x2b, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x34, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, + 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x63, 0x63, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x65, + 0x33, 0x66, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, + 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, + 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, + 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x33, 0x39, + 0x36, 0x36, 0x33, 0x33, 0x33, 0x30, 0x33, 0x34, 0x36, 0x36, 0x33, 0x32, + 0x33, 0x36, 0x33, 0x32, 0x33, 0x32, 0x36, 0x32, 0x33, 0x31, 0x33, 0x38, + 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, + 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x33, 0x31, 0x33, 0x32, 0x36, 0x32, 0x33, 0x35, 0x33, 0x38, 0x33, 0x36, + 0x36, 0x32, 0x33, 0x33, 0x33, 0x32, 0x36, 0x36, 0x36, 0x33, 0x33, 0x34, + 0x36, 0x33, 0x36, 0x35, 0x33, 0x33, 0x33, 0x32, 0x2c, 0x50, 0x53, 0x34, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x31, 0x33, 0x37, + 0x33, 0x32, 0x33, 0x31, 0x33, 0x33, 0x36, 0x35, 0x36, 0x31, 0x36, 0x33, + 0x36, 0x32, 0x33, 0x35, 0x36, 0x31, 0x33, 0x36, 0x36, 0x36, 0x33, 0x32, + 0x33, 0x30, 0x33, 0x35, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, + 0x31, 0x36, 0x36, 0x33, 0x38, 0x33, 0x38, 0x33, 0x33, 0x36, 0x33, 0x33, + 0x34, 0x33, 0x39, 0x33, 0x31, 0x33, 0x32, 0x33, 0x30, 0x33, 0x33, 0x33, + 0x38, 0x33, 0x35, 0x33, 0x39, 0x36, 0x33, 0x2c, 0x50, 0x53, 0x34, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x33, 0x34, 0x36, 0x31, 0x33, 0x31, 0x33, 0x39, 0x33, 0x37, 0x36, + 0x36, 0x33, 0x34, 0x36, 0x32, 0x36, 0x31, 0x33, 0x33, 0x33, 0x33, 0x36, + 0x35, 0x33, 0x30, 0x33, 0x38, 0x36, 0x34, 0x33, 0x30, 0x2c, 0x50, 0x53, + 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x35, 0x36, 0x34, 0x33, + 0x30, 0x33, 0x31, 0x33, 0x30, 0x33, 0x30, 0x33, 0x33, 0x33, 0x32, 0x36, + 0x31, 0x33, 0x30, 0x33, 0x31, 0x36, 0x33, 0x33, 0x30, 0x33, 0x35, 0x33, + 0x35, 0x36, 0x34, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, + 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, + 0x0d, 0x0a, 0x33, 0x37, 0x36, 0x32, 0x36, 0x32, 0x33, 0x33, 0x33, 0x33, + 0x36, 0x32, 0x33, 0x35, 0x33, 0x34, 0x33, 0x39, 0x33, 0x37, 0x33, 0x33, + 0x33, 0x39, 0x36, 0x31, 0x33, 0x35, 0x33, 0x37, 0x33, 0x32, 0x2c, 0x50, + 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x37, 0x36, 0x32, + 0x36, 0x34, 0x36, 0x34, 0x33, 0x34, 0x33, 0x34, 0x33, 0x30, 0x36, 0x33, + 0x36, 0x35, 0x36, 0x32, 0x33, 0x31, 0x36, 0x36, 0x36, 0x31, 0x36, 0x34, + 0x33, 0x38, 0x36, 0x33, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, + 0x0d, 0x0a, 0x33, 0x38, 0x33, 0x39, 0x33, 0x31, 0x36, 0x31, 0x36, 0x33, + 0x36, 0x32, 0x36, 0x31, 0x36, 0x35, 0x33, 0x36, 0x33, 0x36, 0x36, 0x35, + 0x33, 0x35, 0x33, 0x32, 0x33, 0x38, 0x36, 0x36, 0x33, 0x39, 0x2c, 0x50, + 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x33, 0x33, 0x31, + 0x33, 0x37, 0x33, 0x33, 0x33, 0x39, 0x33, 0x35, 0x33, 0x35, 0x36, 0x36, + 0x33, 0x33, 0x33, 0x39, 0x36, 0x35, 0x36, 0x35, 0x36, 0x34, 0x33, 0x34, + 0x33, 0x39, 0x36, 0x32, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, + 0x0d, 0x0a, 0x36, 0x33, 0x33, 0x39, 0x33, 0x36, 0x36, 0x32, 0x33, 0x36, + 0x33, 0x38, 0x33, 0x36, 0x33, 0x38, 0x33, 0x34, 0x33, 0x39, 0x33, 0x35, + 0x33, 0x30, 0x36, 0x34, 0x36, 0x36, 0x33, 0x39, 0x33, 0x39, 0x2c, 0x50, + 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x35, 0x33, 0x36, 0x36, + 0x34, 0x36, 0x35, 0x36, 0x35, 0x36, 0x33, 0x36, 0x34, 0x36, 0x33, 0x36, + 0x31, 0x33, 0x37, 0x36, 0x35, 0x33, 0x33, 0x36, 0x33, 0x33, 0x37, 0x36, + 0x35, 0x33, 0x31, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x36, 0x36, 0x31, 0x33, 0x35, 0x33, + 0x32, 0x33, 0x30, 0x33, 0x39, 0x36, 0x35, 0x33, 0x38, 0x33, 0x35, 0x33, + 0x34, 0x33, 0x39, 0x36, 0x36, 0x33, 0x38, 0x36, 0x31, 0x33, 0x32, 0x33, + 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, + 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x65, 0x36, 0x30, 0x63, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x65, 0x33, 0x66, 0x30, 0x30, 0x2c, + 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x37, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x65, 0x36, 0x30, 0x63, + 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x65, 0x33, 0x66, 0x38, 0x30, + 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, + 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x65, 0x36, 0x30, + 0x63, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, + 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x33, 0x32, 0x33, 0x34, 0x36, 0x34, 0x36, 0x35, 0x33, + 0x34, 0x36, 0x35, 0x33, 0x33, 0x36, 0x31, 0x36, 0x32, 0x36, 0x33, 0x33, + 0x38, 0x36, 0x35, 0x33, 0x39, 0x33, 0x32, 0x33, 0x39, 0x33, 0x32, 0x2c, + 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, + 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x32, 0x36, 0x33, 0x33, 0x35, + 0x33, 0x32, 0x36, 0x34, 0x33, 0x37, 0x33, 0x34, 0x33, 0x37, 0x36, 0x36, + 0x33, 0x32, 0x36, 0x35, 0x36, 0x36, 0x36, 0x34, 0x33, 0x38, 0x33, 0x37, + 0x33, 0x33, 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x37, 0x33, 0x36, 0x33, 0x37, 0x36, 0x34, + 0x33, 0x35, 0x33, 0x37, 0x33, 0x31, 0x33, 0x32, 0x33, 0x39, 0x36, 0x33, + 0x33, 0x32, 0x33, 0x36, 0x33, 0x39, 0x36, 0x36, 0x36, 0x35, 0x36, 0x35, + 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, + 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, + 0x0d, 0x0a, 0x36, 0x31, 0x33, 0x30, 0x33, 0x31, 0x36, 0x32, 0x33, 0x35, + 0x33, 0x31, 0x36, 0x35, 0x33, 0x31, 0x36, 0x33, 0x36, 0x35, 0x33, 0x33, + 0x36, 0x34, 0x33, 0x36, 0x33, 0x34, 0x33, 0x31, 0x33, 0x39, 0x2c, 0x50, + 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x39, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, + 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x34, 0x33, + 0x33, 0x36, 0x32, 0x36, 0x33, 0x33, 0x39, 0x33, 0x39, 0x33, 0x33, 0x36, + 0x32, 0x36, 0x35, 0x33, 0x35, 0x33, 0x30, 0x33, 0x33, 0x33, 0x39, 0x36, + 0x31, 0x36, 0x33, 0x33, 0x32, 0x2c, 0x51, 0x61, 0x6e, 0x62, 0x61, 0x20, + 0x34, 0x52, 0x41, 0x46, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, + 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, + 0x36, 0x36, 0x32, 0x36, 0x36, 0x36, 0x36, 0x33, 0x35, 0x33, 0x38, 0x36, + 0x31, 0x36, 0x36, 0x33, 0x38, 0x36, 0x34, 0x33, 0x33, 0x36, 0x31, 0x33, + 0x30, 0x33, 0x36, 0x33, 0x31, 0x33, 0x37, 0x2c, 0x52, 0x61, 0x7a, 0x65, + 0x72, 0x20, 0x4a, 0x75, 0x6e, 0x67, 0x6c, 0x65, 0x63, 0x61, 0x74, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x66, 0x38, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x62, 0x66, 0x30, + 0x62, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, + 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x4b, 0x69, 0x73, 0x68, + 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x36, 0x32, 0x36, 0x35, 0x33, 0x38, 0x36, 0x31, 0x36, 0x34, 0x33, 0x33, + 0x33, 0x33, 0x36, 0x36, 0x33, 0x36, 0x36, 0x33, 0x33, 0x38, 0x33, 0x33, + 0x33, 0x32, 0x33, 0x39, 0x36, 0x36, 0x36, 0x35, 0x2c, 0x52, 0x61, 0x7a, + 0x65, 0x72, 0x20, 0x4b, 0x69, 0x73, 0x68, 0x69, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x66, + 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, + 0x72, 0x20, 0x52, 0x61, 0x69, 0x6a, 0x75, 0x20, 0x4d, 0x6f, 0x62, 0x69, + 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x37, + 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, + 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, 0x69, 0x6a, 0x75, + 0x20, 0x4d, 0x6f, 0x62, 0x69, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x62, 0x66, 0x37, + 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, + 0x53, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, + 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, + 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x35, 0x61, 0x36, 0x38, 0x36, 0x39, 0x35, 0x38, 0x37, 0x35, 0x32, 0x30, + 0x35, 0x32, 0x36, 0x35, 0x37, 0x34, 0x37, 0x32, 0x36, 0x66, 0x32, 0x30, + 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x32, 0x30, 0x2c, 0x52, 0x65, 0x74, + 0x72, 0x6f, 0x20, 0x42, 0x69, 0x74, 0x20, 0x53, 0x61, 0x74, 0x75, 0x72, + 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x32, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x32, + 0x34, 0x31, 0x37, 0x38, 0x36, 0x35, 0x37, 0x33, 0x32, 0x30, 0x33, 0x31, + 0x33, 0x31, 0x34, 0x62, 0x36, 0x35, 0x37, 0x39, 0x37, 0x33, 0x32, 0x30, + 0x34, 0x37, 0x36, 0x31, 0x36, 0x64, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, + 0x20, 0x42, 0x69, 0x74, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, + 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, + 0x36, 0x33, 0x31, 0x33, 0x39, 0x33, 0x38, 0x33, 0x30, 0x36, 0x35, 0x33, + 0x39, 0x33, 0x32, 0x36, 0x32, 0x33, 0x33, 0x33, 0x39, 0x33, 0x37, 0x33, + 0x32, 0x36, 0x31, 0x33, 0x33, 0x36, 0x31, 0x2c, 0x52, 0x65, 0x74, 0x72, + 0x6f, 0x20, 0x42, 0x69, 0x74, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, + 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x35, 0x32, 0x36, 0x35, 0x37, 0x34, 0x37, 0x32, 0x36, 0x66, 0x34, 0x36, + 0x36, 0x63, 0x36, 0x31, 0x36, 0x37, 0x32, 0x30, 0x35, 0x37, 0x36, 0x39, + 0x37, 0x32, 0x36, 0x35, 0x36, 0x34, 0x32, 0x30, 0x2c, 0x52, 0x65, 0x74, + 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x31, 0x33, + 0x34, 0x33, 0x37, 0x33, 0x39, 0x33, 0x35, 0x33, 0x37, 0x36, 0x34, 0x33, + 0x36, 0x33, 0x31, 0x36, 0x35, 0x33, 0x34, 0x33, 0x32, 0x33, 0x37, 0x33, + 0x30, 0x33, 0x33, 0x33, 0x36, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, + 0x36, 0x35, 0x33, 0x31, 0x33, 0x30, 0x33, 0x37, 0x33, 0x33, 0x36, 0x35, + 0x36, 0x31, 0x33, 0x35, 0x33, 0x38, 0x33, 0x33, 0x33, 0x32, 0x33, 0x35, + 0x33, 0x30, 0x33, 0x30, 0x33, 0x36, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, + 0x69, 0x64, 0x20, 0x50, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x20, 0x32, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x34, 0x33, 0x36, 0x33, 0x33, 0x36, + 0x33, 0x33, 0x33, 0x36, 0x36, 0x33, 0x33, 0x33, 0x36, 0x33, 0x37, 0x33, + 0x36, 0x33, 0x39, 0x33, 0x30, 0x33, 0x38, 0x33, 0x31, 0x33, 0x34, 0x36, + 0x33, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x6b, 0x2c, + 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x36, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x37, + 0x33, 0x39, 0x33, 0x32, 0x33, 0x34, 0x33, 0x37, 0x33, 0x35, 0x33, 0x33, + 0x36, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x32, 0x33, 0x36, 0x33, 0x33, + 0x36, 0x34, 0x36, 0x35, 0x33, 0x31, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, + 0x55, 0x53, 0x42, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x52, 0x65, 0x74, 0x72, + 0x6f, 0x50, 0x6f, 0x72, 0x74, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x62, 0x36, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, + 0x31, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x30, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x33, 0x36, 0x35, 0x36, + 0x31, 0x36, 0x63, 0x36, 0x39, 0x36, 0x35, 0x34, 0x33, 0x36, 0x66, 0x36, + 0x64, 0x37, 0x30, 0x37, 0x35, 0x37, 0x34, 0x36, 0x39, 0x36, 0x65, 0x36, + 0x37, 0x32, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x55, 0x53, 0x42, + 0x20, 0x4e, 0x36, 0x34, 0x20, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x50, 0x6f, + 0x72, 0x74, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, + 0x31, 0x38, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, + 0x36, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x39, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x39, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x32, 0x36, 0x35, 0x37, 0x34, 0x37, 0x32, + 0x36, 0x66, 0x35, 0x35, 0x35, 0x33, 0x34, 0x32, 0x32, 0x65, 0x36, 0x33, + 0x36, 0x66, 0x36, 0x64, 0x32, 0x30, 0x35, 0x33, 0x34, 0x65, 0x34, 0x35, + 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x55, 0x53, 0x42, 0x20, 0x53, 0x4e, + 0x45, 0x53, 0x20, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x50, 0x6f, 0x72, 0x74, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x30, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x32, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x34, 0x36, 0x34, 0x33, 0x30, 0x33, 0x37, + 0x36, 0x33, 0x33, 0x30, 0x33, 0x38, 0x33, 0x38, 0x36, 0x32, 0x33, 0x38, + 0x33, 0x30, 0x33, 0x39, 0x36, 0x36, 0x33, 0x37, 0x36, 0x31, 0x33, 0x37, + 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x55, 0x53, 0x42, 0x20, 0x53, 0x4e, + 0x45, 0x53, 0x20, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x50, 0x6f, 0x72, 0x74, + 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x30, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x32, 0x2c, 0x78, + 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x37, 0x36, 0x35, 0x36, 0x35, 0x36, 0x34, + 0x33, 0x34, 0x36, 0x35, 0x33, 0x33, 0x36, 0x34, 0x33, 0x31, 0x33, 0x38, + 0x36, 0x33, 0x36, 0x34, 0x33, 0x36, 0x33, 0x35, 0x36, 0x32, 0x33, 0x30, + 0x2c, 0x52, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, + 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, + 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x33, + 0x33, 0x37, 0x33, 0x33, 0x33, 0x36, 0x33, 0x39, 0x36, 0x36, 0x33, 0x34, + 0x33, 0x31, 0x36, 0x34, 0x33, 0x34, 0x33, 0x32, 0x33, 0x33, 0x33, 0x37, + 0x36, 0x36, 0x36, 0x33, 0x36, 0x31, 0x2c, 0x52, 0x75, 0x6d, 0x62, 0x6c, + 0x65, 0x50, 0x61, 0x64, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x32, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x32, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, + 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x36, 0x33, 0x36, 0x33, 0x35, + 0x33, 0x37, 0x33, 0x30, 0x33, 0x34, 0x33, 0x35, 0x33, 0x33, 0x33, 0x35, + 0x36, 0x36, 0x33, 0x38, 0x36, 0x36, 0x33, 0x38, 0x33, 0x36, 0x36, 0x33, + 0x33, 0x33, 0x2c, 0x53, 0x61, 0x6d, 0x73, 0x75, 0x6e, 0x67, 0x20, 0x45, + 0x49, 0x47, 0x50, 0x32, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, + 0x0d, 0x0a, 0x35, 0x33, 0x36, 0x31, 0x36, 0x64, 0x37, 0x33, 0x37, 0x35, + 0x36, 0x65, 0x36, 0x37, 0x32, 0x30, 0x34, 0x37, 0x36, 0x31, 0x36, 0x64, + 0x36, 0x35, 0x32, 0x30, 0x35, 0x30, 0x36, 0x31, 0x36, 0x34, 0x2c, 0x53, + 0x61, 0x6d, 0x73, 0x75, 0x6e, 0x67, 0x20, 0x45, 0x49, 0x47, 0x50, 0x32, + 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x36, + 0x33, 0x38, 0x36, 0x35, 0x36, 0x35, 0x33, 0x39, 0x36, 0x32, 0x33, 0x38, + 0x33, 0x36, 0x33, 0x35, 0x33, 0x34, 0x33, 0x31, 0x33, 0x38, 0x36, 0x33, + 0x33, 0x35, 0x33, 0x30, 0x36, 0x35, 0x2c, 0x53, 0x61, 0x6e, 0x77, 0x61, + 0x20, 0x50, 0x6c, 0x61, 0x79, 0x4f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x20, + 0x4d, 0x6f, 0x62, 0x69, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x31, + 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x32, 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, + 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x32, 0x33, 0x38, 0x33, 0x31, 0x36, 0x35, + 0x33, 0x31, 0x36, 0x33, 0x33, 0x33, 0x33, 0x38, 0x33, 0x37, 0x36, 0x36, + 0x33, 0x33, 0x36, 0x33, 0x33, 0x38, 0x33, 0x37, 0x33, 0x32, 0x36, 0x31, + 0x2c, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x36, 0x31, 0x33, 0x38, 0x36, + 0x35, 0x33, 0x39, 0x36, 0x35, 0x33, 0x30, 0x33, 0x35, 0x33, 0x33, 0x33, + 0x38, 0x33, 0x37, 0x33, 0x37, 0x36, 0x33, 0x36, 0x32, 0x33, 0x34, 0x33, + 0x31, 0x2c, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x36, 0x31, 0x33, 0x31, 0x36, 0x32, 0x33, 0x32, 0x33, 0x33, 0x36, 0x32, + 0x36, 0x32, 0x33, 0x37, 0x33, 0x36, 0x33, 0x31, 0x33, 0x34, 0x33, 0x31, + 0x33, 0x37, 0x36, 0x33, 0x33, 0x36, 0x33, 0x31, 0x2c, 0x53, 0x61, 0x74, + 0x75, 0x72, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x33, 0x30, 0x33, 0x35, 0x33, 0x38, 0x33, 0x35, 0x33, 0x33, 0x33, + 0x33, 0x33, 0x38, 0x36, 0x31, 0x33, 0x31, 0x33, 0x30, 0x33, 0x37, 0x33, + 0x33, 0x36, 0x33, 0x36, 0x34, 0x36, 0x33, 0x33, 0x37, 0x2c, 0x53, 0x47, + 0x20, 0x48, 0x35, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, + 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x36, 0x36, 0x33, 0x38, 0x36, 0x32, 0x36, 0x32, 0x33, + 0x36, 0x36, 0x35, 0x33, 0x36, 0x36, 0x35, 0x33, 0x37, 0x36, 0x35, 0x33, + 0x33, 0x33, 0x32, 0x33, 0x35, 0x33, 0x34, 0x33, 0x36, 0x33, 0x34, 0x2c, + 0x53, 0x47, 0x20, 0x48, 0x35, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x36, 0x36, 0x33, 0x33, 0x31, 0x33, 0x32, + 0x33, 0x39, 0x33, 0x33, 0x36, 0x33, 0x33, 0x35, 0x33, 0x35, 0x33, 0x31, + 0x33, 0x37, 0x33, 0x34, 0x36, 0x35, 0x36, 0x33, 0x33, 0x30, 0x36, 0x34, + 0x2c, 0x53, 0x47, 0x20, 0x48, 0x35, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, + 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, + 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x32, 0x36, 0x35, 0x33, 0x37, + 0x36, 0x31, 0x36, 0x33, 0x36, 0x33, 0x36, 0x36, 0x33, 0x39, 0x33, 0x33, + 0x36, 0x36, 0x36, 0x31, 0x33, 0x31, 0x33, 0x35, 0x33, 0x36, 0x36, 0x33, + 0x33, 0x38, 0x2c, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x50, 0x2c, 0x61, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, + 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, + 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x33, 0x37, 0x36, + 0x36, 0x36, 0x32, 0x36, 0x36, 0x36, 0x36, 0x36, 0x31, 0x36, 0x33, 0x36, + 0x32, 0x36, 0x35, 0x33, 0x31, 0x33, 0x32, 0x36, 0x34, 0x36, 0x31, 0x33, + 0x30, 0x33, 0x39, 0x2c, 0x53, 0x4e, 0x45, 0x53, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, + 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, + 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x35, 0x33, 0x34, 0x36, 0x34, 0x33, 0x32, 0x66, 0x35, 0x35, 0x35, 0x33, + 0x34, 0x32, 0x32, 0x30, 0x35, 0x30, 0x36, 0x31, 0x36, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x4e, 0x45, + 0x53, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, + 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, + 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, + 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x35, 0x35, 0x35, 0x33, 0x34, 0x32, 0x32, 0x30, 0x34, 0x37, 0x36, + 0x31, 0x36, 0x64, 0x36, 0x35, 0x37, 0x30, 0x36, 0x31, 0x36, 0x34, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x4e, + 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x33, 0x33, 0x30, + 0x33, 0x39, 0x36, 0x34, 0x33, 0x30, 0x33, 0x34, 0x36, 0x32, 0x33, 0x36, + 0x36, 0x31, 0x33, 0x36, 0x36, 0x31, 0x36, 0x32, 0x36, 0x36, 0x36, 0x35, + 0x33, 0x35, 0x36, 0x31, 0x2c, 0x53, 0x6f, 0x6e, 0x79, 0x20, 0x50, 0x53, + 0x50, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, + 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x32, 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x32, 0x38, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x34, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x33, 0x33, 0x37, + 0x36, 0x36, 0x33, 0x37, 0x36, 0x34, 0x33, 0x34, 0x36, 0x32, 0x33, 0x34, + 0x33, 0x37, 0x36, 0x36, 0x33, 0x33, 0x33, 0x34, 0x36, 0x32, 0x33, 0x38, + 0x33, 0x32, 0x33, 0x35, 0x2c, 0x53, 0x6f, 0x6e, 0x79, 0x20, 0x56, 0x69, + 0x74, 0x61, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, + 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x34, 0x37, 0x36, 0x66, 0x36, 0x66, 0x36, 0x37, 0x36, 0x63, 0x36, + 0x35, 0x32, 0x30, 0x34, 0x63, 0x34, 0x63, 0x34, 0x33, 0x32, 0x30, 0x35, + 0x33, 0x37, 0x34, 0x36, 0x31, 0x36, 0x34, 0x36, 0x39, 0x2c, 0x53, 0x74, + 0x61, 0x64, 0x69, 0x61, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x33, 0x37, 0x34, 0x36, + 0x31, 0x36, 0x34, 0x36, 0x39, 0x36, 0x31, 0x34, 0x65, 0x33, 0x38, 0x34, + 0x38, 0x35, 0x33, 0x32, 0x64, 0x36, 0x35, 0x33, 0x32, 0x36, 0x33, 0x33, + 0x34, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x61, 0x64, 0x69, 0x61, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, + 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, + 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x31, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, + 0x74, 0x65, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x36, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, + 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x31, 0x34, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x37, 0x65, 0x30, 0x66, 0x30, 0x30, 0x2c, 0x53, + 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x4e, + 0x69, 0x6d, 0x62, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x78, + 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x35, 0x33, 0x30, 0x36, 0x34, 0x33, + 0x36, 0x33, 0x39, 0x36, 0x34, 0x33, 0x37, 0x33, 0x37, 0x33, 0x31, 0x33, + 0x35, 0x33, 0x38, 0x33, 0x36, 0x36, 0x35, 0x36, 0x34, 0x36, 0x34, 0x36, + 0x34, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, + 0x73, 0x20, 0x4e, 0x69, 0x6d, 0x62, 0x75, 0x73, 0x20, 0x50, 0x6c, 0x75, + 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, + 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x35, 0x34, 0x34, 0x37, 0x35, 0x61, 0x32, 0x30, 0x34, 0x33, 0x36, 0x66, + 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x66, 0x36, 0x63, 0x36, 0x63, + 0x36, 0x35, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x47, 0x5a, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x32, 0x33, 0x36, + 0x33, 0x34, 0x33, 0x34, 0x33, 0x35, 0x33, 0x35, 0x33, 0x32, 0x33, 0x38, + 0x36, 0x32, 0x33, 0x38, 0x33, 0x33, 0x36, 0x36, 0x36, 0x33, 0x36, 0x34, + 0x33, 0x38, 0x33, 0x36, 0x2c, 0x54, 0x47, 0x5a, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x37, 0x33, 0x32, 0x33, 0x32, 0x33, 0x36, + 0x36, 0x33, 0x33, 0x37, 0x36, 0x33, 0x36, 0x36, 0x36, 0x34, 0x36, 0x35, + 0x33, 0x31, 0x36, 0x33, 0x36, 0x35, 0x33, 0x31, 0x33, 0x32, 0x33, 0x36, + 0x2c, 0x54, 0x48, 0x45, 0x43, 0x36, 0x34, 0x20, 0x4a, 0x6f, 0x79, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, + 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x33, 0x38, 0x33, 0x34, 0x36, 0x31, 0x36, 0x32, 0x33, 0x32, 0x36, 0x32, + 0x33, 0x32, 0x33, 0x34, 0x36, 0x35, 0x33, 0x33, 0x33, 0x31, 0x36, 0x31, + 0x36, 0x34, 0x33, 0x36, 0x33, 0x33, 0x33, 0x36, 0x2c, 0x54, 0x48, 0x45, + 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x64, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x65, 0x33, 0x66, 0x30, 0x30, 0x2c, + 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x4d, 0x61, 0x73, 0x74, 0x65, 0x72, + 0x20, 0x65, 0x53, 0x77, 0x61, 0x70, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x34, 0x37, + 0x37, 0x36, 0x39, 0x36, 0x65, 0x32, 0x30, 0x35, 0x35, 0x35, 0x33, 0x34, + 0x32, 0x32, 0x30, 0x34, 0x61, 0x36, 0x66, 0x37, 0x39, 0x37, 0x33, 0x37, + 0x34, 0x36, 0x39, 0x36, 0x33, 0x2c, 0x54, 0x77, 0x69, 0x6e, 0x20, 0x4a, + 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x32, + 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x32, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x32, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x33, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x32, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x79, + 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x33, 0x30, 0x36, 0x32, 0x33, 0x37, 0x33, 0x39, 0x33, 0x34, 0x33, 0x30, + 0x33, 0x39, 0x36, 0x34, 0x33, 0x38, 0x33, 0x30, 0x33, 0x33, 0x33, 0x32, + 0x36, 0x36, 0x33, 0x34, 0x36, 0x34, 0x33, 0x39, 0x2c, 0x56, 0x61, 0x6c, + 0x76, 0x65, 0x20, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x70, 0x61, + 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x70, 0x61, + 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x31, 0x36, 0x34, 0x33, 0x33, 0x36, 0x35, + 0x36, 0x36, 0x36, 0x34, 0x33, 0x32, 0x33, 0x38, 0x36, 0x31, 0x33, 0x33, + 0x33, 0x34, 0x36, 0x36, 0x33, 0x39, 0x33, 0x38, 0x33, 0x39, 0x33, 0x37, + 0x2c, 0x56, 0x61, 0x6c, 0x76, 0x65, 0x20, 0x53, 0x74, 0x65, 0x61, 0x6d, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x32, + 0x34, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x32, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x30, 0x33, 0x38, + 0x36, 0x34, 0x33, 0x38, 0x33, 0x31, 0x33, 0x35, 0x36, 0x34, 0x33, 0x30, + 0x36, 0x31, 0x36, 0x31, 0x33, 0x39, 0x33, 0x35, 0x33, 0x37, 0x33, 0x33, + 0x33, 0x36, 0x36, 0x33, 0x2c, 0x57, 0x69, 0x69, 0x20, 0x43, 0x6c, 0x61, + 0x73, 0x73, 0x69, 0x63, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, + 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x32, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, + 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x79, + 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x33, 0x33, 0x33, 0x33, 0x33, 0x30, 0x33, 0x34, 0x36, 0x34, 0x36, 0x33, + 0x33, 0x36, 0x33, 0x34, 0x36, 0x33, 0x33, 0x39, 0x36, 0x34, 0x36, 0x35, + 0x33, 0x38, 0x36, 0x34, 0x33, 0x36, 0x33, 0x33, 0x2c, 0x57, 0x69, 0x69, + 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x41, 0x64, 0x61, + 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x62, + 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, + 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, + 0x32, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x33, 0x66, 0x30, 0x30, + 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x30, 0x33, 0x39, 0x36, + 0x32, 0x33, 0x32, 0x33, 0x39, 0x33, 0x31, 0x36, 0x32, 0x33, 0x34, 0x36, + 0x33, 0x33, 0x30, 0x33, 0x32, 0x36, 0x33, 0x33, 0x34, 0x36, 0x33, 0x36, + 0x35, 0x36, 0x36, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, + 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x33, 0x31, 0x33, 0x30, + 0x33, 0x38, 0x33, 0x32, 0x33, 0x37, 0x33, 0x30, 0x33, 0x38, 0x33, 0x38, + 0x36, 0x34, 0x36, 0x36, 0x36, 0x34, 0x36, 0x33, 0x33, 0x38, 0x33, 0x35, + 0x33, 0x33, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x38, 0x36, 0x32, 0x36, 0x66, 0x37, + 0x38, 0x32, 0x30, 0x33, 0x33, 0x33, 0x36, 0x33, 0x30, 0x32, 0x30, 0x35, + 0x37, 0x36, 0x39, 0x37, 0x32, 0x36, 0x35, 0x36, 0x63, 0x36, 0x35, 0x37, + 0x33, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x36, 0x35, 0x33, 0x35, 0x33, 0x33, 0x33, 0x31, 0x33, 0x38, 0x36, + 0x36, 0x36, 0x32, 0x33, 0x34, 0x33, 0x33, 0x33, 0x38, 0x36, 0x34, 0x33, + 0x39, 0x33, 0x39, 0x36, 0x34, 0x33, 0x36, 0x33, 0x36, 0x2c, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x36, 0x35, 0x36, 0x31, 0x33, 0x35, 0x33, 0x32, 0x33, 0x38, 0x36, 0x36, + 0x33, 0x33, 0x33, 0x37, 0x33, 0x39, 0x36, 0x33, 0x36, 0x31, 0x36, 0x34, + 0x36, 0x32, 0x33, 0x36, 0x33, 0x30, 0x33, 0x38, 0x2c, 0x58, 0x62, 0x6f, + 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x34, + 0x37, 0x36, 0x35, 0x36, 0x65, 0x36, 0x35, 0x37, 0x32, 0x36, 0x39, 0x36, + 0x33, 0x32, 0x30, 0x35, 0x38, 0x32, 0x64, 0x34, 0x32, 0x36, 0x66, 0x37, + 0x38, 0x32, 0x30, 0x37, 0x30, 0x36, 0x31, 0x2c, 0x58, 0x62, 0x6f, 0x78, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x34, 0x64, 0x36, 0x39, 0x36, 0x33, 0x37, 0x32, 0x36, + 0x66, 0x37, 0x33, 0x36, 0x66, 0x36, 0x36, 0x37, 0x34, 0x32, 0x30, 0x35, + 0x38, 0x32, 0x64, 0x34, 0x32, 0x36, 0x66, 0x37, 0x38, 0x32, 0x30, 0x2c, + 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x34, 0x36, 0x33, 0x33, + 0x34, 0x33, 0x36, 0x33, 0x31, 0x33, 0x39, 0x36, 0x35, 0x36, 0x35, 0x36, + 0x36, 0x36, 0x34, 0x33, 0x37, 0x33, 0x36, 0x33, 0x34, 0x33, 0x32, 0x33, + 0x33, 0x36, 0x34, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x39, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x66, + 0x66, 0x30, 0x37, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, + 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x39, + 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x37, 0x33, + 0x66, 0x38, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, + 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x32, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x65, 0x33, 0x66, 0x30, 0x30, 0x2c, + 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x37, + 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, + 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x66, 0x66, 0x65, 0x33, 0x66, 0x38, 0x30, 0x2c, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x79, + 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, + 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x66, + 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, + 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, + 0x62, 0x31, 0x37, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, + 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x38, 0x30, + 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x79, 0x3a, 0x62, + 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x66, 0x64, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, + 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, + 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x33, 0x33, 0x33, 0x35, 0x36, 0x36, 0x36, 0x31, 0x33, + 0x32, 0x33, 0x32, 0x36, 0x36, 0x33, 0x33, 0x33, 0x37, 0x33, 0x33, 0x33, + 0x37, 0x33, 0x38, 0x36, 0x35, 0x36, 0x35, 0x36, 0x33, 0x36, 0x36, 0x2c, + 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x33, 0x34, 0x33, 0x35, 0x36, 0x31, 0x33, 0x36, 0x36, 0x33, 0x33, + 0x33, 0x36, 0x36, 0x36, 0x31, 0x33, 0x35, 0x33, 0x30, 0x33, 0x31, 0x36, + 0x33, 0x33, 0x38, 0x33, 0x37, 0x36, 0x31, 0x33, 0x36, 0x2c, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x78, 0x3a, 0x62, + 0x31, 0x37, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, + 0x2c, 0x0d, 0x0a, 0x33, 0x35, 0x36, 0x32, 0x33, 0x39, 0x36, 0x35, 0x33, + 0x37, 0x33, 0x32, 0x36, 0x34, 0x33, 0x38, 0x36, 0x32, 0x33, 0x38, 0x33, + 0x35, 0x33, 0x34, 0x33, 0x33, 0x36, 0x35, 0x36, 0x31, 0x33, 0x38, 0x2c, + 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x33, 0x36, 0x36, 0x31, 0x36, 0x31, 0x33, 0x31, 0x36, 0x34, 0x33, + 0x33, 0x36, 0x31, 0x33, 0x33, 0x33, 0x33, 0x33, 0x37, 0x33, 0x39, 0x36, + 0x32, 0x36, 0x31, 0x36, 0x36, 0x36, 0x34, 0x33, 0x33, 0x2c, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x35, 0x38, 0x36, 0x32, 0x36, 0x66, 0x37, 0x38, 0x32, 0x30, 0x35, + 0x37, 0x36, 0x39, 0x37, 0x32, 0x36, 0x35, 0x36, 0x63, 0x36, 0x35, 0x37, + 0x33, 0x37, 0x33, 0x32, 0x30, 0x34, 0x33, 0x36, 0x66, 0x2c, 0x58, 0x62, + 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, + 0x38, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, + 0x6e, 0x65, 0x20, 0x45, 0x6c, 0x69, 0x74, 0x65, 0x20, 0x32, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, + 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, + 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, + 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, + 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, + 0x33, 0x66, 0x38, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, + 0x65, 0x20, 0x45, 0x6c, 0x69, 0x74, 0x65, 0x20, 0x32, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, + 0x66, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, + 0x20, 0x45, 0x6c, 0x69, 0x74, 0x65, 0x20, 0x32, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x36, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, + 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, + 0x30, 0x65, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, + 0x38, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, + 0x6e, 0x65, 0x20, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, + 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, + 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, + 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x61, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x53, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, + 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, + 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x66, + 0x64, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x37, 0x66, 0x33, + 0x66, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, + 0x20, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x37, 0x38, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, + 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, + 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, + 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x33, 0x66, + 0x38, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, + 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, + 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, + 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, + 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, + 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, + 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, + 0x0d, 0x0a, 0x36, 0x35, 0x36, 0x33, 0x33, 0x30, 0x33, 0x38, 0x33, 0x36, + 0x33, 0x38, 0x33, 0x32, 0x33, 0x35, 0x33, 0x36, 0x33, 0x34, 0x36, 0x35, + 0x33, 0x38, 0x33, 0x36, 0x33, 0x39, 0x36, 0x32, 0x33, 0x39, 0x2c, 0x58, + 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, + 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, + 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, 0x32, + 0x37, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x33, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x58, 0x69, + 0x61, 0x6f, 0x4d, 0x69, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x37, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, + 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, + 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x0d, 0x0a, 0x23, 0x20, 0x69, 0x4f, 0x53, + 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x31, 0x2c, 0x2a, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, + 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x34, 0x66, 0x30, 0x36, 0x36, 0x64, 0x30, 0x31, 0x2c, 0x2a, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, + 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x63, 0x66, 0x30, 0x37, 0x36, 0x64, 0x30, 0x31, 0x2c, 0x2a, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, + 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x66, 0x30, 0x37, 0x36, 0x64, 0x30, + 0x31, 0x2c, 0x2a, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, + 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x37, 0x36, 0x64, 0x30, 0x31, + 0x2c, 0x2a, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, + 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x32, 0x2c, 0x2a, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, + 0x64, 0x65, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, + 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x36, 0x36, 0x64, 0x30, 0x32, + 0x2c, 0x2a, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x38, 0x61, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x33, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x37, 0x30, + 0x30, 0x30, 0x30, 0x2c, 0x42, 0x61, 0x63, 0x6b, 0x62, 0x6f, 0x6e, 0x65, + 0x20, 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, + 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, + 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x38, 0x61, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x37, 0x30, 0x30, + 0x30, 0x30, 0x2c, 0x42, 0x61, 0x63, 0x6b, 0x62, 0x6f, 0x6e, 0x65, 0x20, + 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, + 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, + 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, + 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, + 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, + 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, + 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x34, 0x64, 0x34, 0x36, 0x36, 0x39, 0x34, + 0x37, 0x36, 0x31, 0x36, 0x64, 0x36, 0x35, 0x37, 0x30, 0x36, 0x31, 0x36, + 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4d, 0x46, 0x69, 0x20, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, + 0x65, 0x64, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, + 0x34, 0x64, 0x34, 0x36, 0x36, 0x39, 0x34, 0x37, 0x36, 0x31, 0x36, 0x64, + 0x36, 0x35, 0x37, 0x30, 0x36, 0x31, 0x36, 0x34, 0x30, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x46, 0x69, + 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, + 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, + 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, + 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, + 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, + 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, + 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x66, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, + 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, + 0x68, 0x20, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x4c, + 0x29, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, + 0x34, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, + 0x38, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, + 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, + 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, + 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x4a, + 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x4c, 0x29, 0x2c, 0x2b, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x2b, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x2d, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x2d, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, + 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, + 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, + 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, + 0x66, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, + 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, + 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x4c, 0x2f, 0x52, + 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, + 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x32, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x64, 0x66, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, + 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, + 0x63, 0x68, 0x20, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, + 0x4c, 0x2f, 0x52, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, + 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, + 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, + 0x6e, 0x20, 0x28, 0x52, 0x29, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x2d, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x2d, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x61, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, + 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, + 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x64, 0x66, 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, 0x2c, + 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, + 0x74, 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, + 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, + 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x38, 0x37, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, + 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, + 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, + 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, + 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, + 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, + 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x39, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, + 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, + 0x39, 0x30, 0x30, 0x30, 0x30, 0x64, 0x66, 0x30, 0x37, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, + 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, + 0x39, 0x30, 0x30, 0x30, 0x30, 0x64, 0x66, 0x38, 0x37, 0x30, 0x30, 0x30, + 0x31, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, + 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, + 0x39, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x37, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, + 0x69, 0x64, 0x65, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, + 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, + 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, + 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, 0x39, 0x30, + 0x30, 0x30, 0x30, 0x66, 0x66, 0x38, 0x37, 0x30, 0x30, 0x30, 0x31, 0x2c, + 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, + 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, + 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, + 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, + 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, + 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, + 0x65, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, + 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, + 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, + 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, + 0x74, 0x6f, 0x75, 0x63, 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, 0x31, 0x31, + 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, + 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, 0x39, 0x30, 0x30, + 0x30, 0x30, 0x66, 0x66, 0x38, 0x37, 0x36, 0x64, 0x30, 0x31, 0x2c, 0x50, + 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x65, 0x36, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x64, 0x66, + 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x74, 0x6f, 0x75, + 0x63, 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, + 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, + 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x65, 0x36, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x66, + 0x66, 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, + 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, + 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, + 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, + 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x39, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x74, 0x6f, 0x75, 0x63, + 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x36, 0x64, 0x30, 0x33, 0x2c, 0x52, 0x65, 0x6d, 0x6f, 0x74, + 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x30, + 0x30, 0x36, 0x64, 0x30, 0x33, 0x2c, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, + 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, + 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, + 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, + 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x36, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, + 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, + 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, + 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, + 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, + 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x66, 0x30, 0x37, 0x30, 0x30, 0x30, 0x31, 0x2c, 0x58, 0x62, 0x6f, + 0x78, 0x20, 0x45, 0x6c, 0x69, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, + 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, + 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, + 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, + 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, + 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, + 0x30, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, + 0x32, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x33, 0x3a, 0x62, 0x31, + 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x34, 0x3a, 0x62, 0x31, + 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, + 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x37, 0x30, + 0x30, 0x30, 0x31, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x45, 0x6c, 0x69, + 0x74, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, + 0x31, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, + 0x32, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, + 0x33, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, + 0x34, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, + 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, + 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, + 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, + 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, + 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, + 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, + 0x64, 0x66, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, + 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, + 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, + 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, + 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, + 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, + 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, + 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, + 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, + 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, + 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, + 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, + 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, + 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, + 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, + 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, + 0x32, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x37, 0x30, 0x30, 0x30, + 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, + 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, + 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, + 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, + 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, + 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, + 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x39, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, + 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, + 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, + 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, + 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, + 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x64, 0x66, 0x38, 0x37, + 0x30, 0x30, 0x30, 0x31, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, + 0x72, 0x69, 0x65, 0x73, 0x20, 0x58, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, + 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, + 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, + 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, + 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, + 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, + 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, + 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, + 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, + 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, + 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, + 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, + 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, + 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, + 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, + 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, + 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, + 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x62, + 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x38, 0x37, 0x30, 0x30, 0x30, 0x31, + 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, + 0x20, 0x58, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, + 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, + 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, + 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, + 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, + 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, + 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, + 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, + 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, + 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, + 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, + 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, + 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, + 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, + 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, + 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a +}; +#define SKA_GAMEPAD_DB_STR (const char*)SKA_GAMEPAD_DB_HEX +const unsigned int SKA_GAMEPAD_DB_SIZE = 503770; + +#endif // if SKA_INPUT diff --git a/seika/input/sdl_input.h b/seika/input/sdl_input.h new file mode 100644 index 0000000..070e1ff --- /dev/null +++ b/seika/input/sdl_input.h @@ -0,0 +1,337 @@ +#pragma once + +#if SKA_INPUT + +#include + +#include "input.h" +#include "sdl_gamepad_db.h" + +typedef struct SkaSDLGamepadData { + SDL_Gamepad* gamepad; + SkaInputDeviceIndex deviceIndex; +} SkaSDLGamepadData; + +typedef struct SkaSDLInputEvent { + SkaInputSourceType sourceType; + SkaInputTriggerType triggerType; + SkaInputDeviceIndex deviceIndex; + SkaInputKey key; + f32 axisMotionValue; +} SkaSDLInputEvent; + +static SkaSDLGamepadData gamepadData[SKA_INPUT_MAX_DEVICES]; +static SkaSDLGamepadData gamepadDataByPlayerIndex[SKA_INPUT_MAX_DEVICES]; +static uint32 activeGamepads = 0; + +SkaInputKey ska_sdl_keycode_to_input_key(SDL_GamepadButton keycode) { + switch ((int32)keycode) { + case SDLK_TAB: return SkaInputKey_KEYBOARD_TAB; + case SDLK_LEFT: return SkaInputKey_KEYBOARD_LEFT; + case SDLK_RIGHT: return SkaInputKey_KEYBOARD_RIGHT; + case SDLK_UP: return SkaInputKey_KEYBOARD_UP; + case SDLK_DOWN: return SkaInputKey_KEYBOARD_DOWN; + case SDLK_PAGEDOWN: return SkaInputKey_KEYBOARD_PAGE_DOWN; + case SDLK_PAGEUP: return SkaInputKey_KEYBOARD_PAGE_UP; + case SDLK_HOME: return SkaInputKey_KEYBOARD_HOME; + case SDLK_END: return SkaInputKey_KEYBOARD_END; + case SDLK_INSERT: return SkaInputKey_KEYBOARD_INSERT; + case SDLK_DELETE: return SkaInputKey_KEYBOARD_DELETE; + case SDLK_BACKSPACE: return SkaInputKey_KEYBOARD_BACKSPACE; + case SDLK_SPACE: return SkaInputKey_KEYBOARD_SPACE; + case SDLK_RETURN: return SkaInputKey_KEYBOARD_RETURN; + case SDLK_ESCAPE: return SkaInputKey_KEYBOARD_ESCAPE; + case SDLK_QUOTE: return SkaInputKey_KEYBOARD_QUOTE; + case SDLK_COMMA: return SkaInputKey_KEYBOARD_COMMA; + case SDLK_MINUS: return SkaInputKey_KEYBOARD_MINUS; + case SDLK_PERIOD: return SkaInputKey_KEYBOARD_PERIOD; + case SDLK_SLASH: return SkaInputKey_KEYBOARD_SLASH; + case SDLK_SEMICOLON: return SkaInputKey_KEYBOARD_SEMICOLON; + case SDLK_EQUALS: return SkaInputKey_KEYBOARD_EQUALS; + case SDLK_LEFTBRACKET: return SkaInputKey_KEYBOARD_LEFT_BRACKET; + case SDLK_BACKSLASH: return SkaInputKey_KEYBOARD_BACKSLASH; + case SDLK_RIGHTBRACKET: return SkaInputKey_KEYBOARD_RIGHT_BRACKET; + case SDLK_BACKQUOTE: return SkaInputKey_KEYBOARD_BACKQUOTE; + case SDLK_CAPSLOCK: return SkaInputKey_KEYBOARD_CAPS_LOCK; + case SDLK_SCROLLLOCK: return SkaInputKey_KEYBOARD_SCROLL_LOCK; + case SDLK_NUMLOCKCLEAR: return SkaInputKey_KEYBOARD_NUM_LOCK_CLEAR; + case SDLK_PRINTSCREEN: return SkaInputKey_KEYBOARD_PRINT_SCREEN; + case SDLK_PAUSE: return SkaInputKey_KEYBOARD_PAUSE; + case SDLK_KP_0: return SkaInputKey_KEYBOARD_KEYPAD_0; + case SDLK_KP_1: return SkaInputKey_KEYBOARD_KEYPAD_1; + case SDLK_KP_2: return SkaInputKey_KEYBOARD_KEYPAD_2; + case SDLK_KP_3: return SkaInputKey_KEYBOARD_KEYPAD_3; + case SDLK_KP_4: return SkaInputKey_KEYBOARD_KEYPAD_4; + case SDLK_KP_5: return SkaInputKey_KEYBOARD_KEYPAD_5; + case SDLK_KP_6: return SkaInputKey_KEYBOARD_KEYPAD_6; + case SDLK_KP_7: return SkaInputKey_KEYBOARD_KEYPAD_7; + case SDLK_KP_8: return SkaInputKey_KEYBOARD_KEYPAD_8; + case SDLK_KP_9: return SkaInputKey_KEYBOARD_KEYPAD_9; + case SDLK_KP_PERIOD: return SkaInputKey_KEYBOARD_KEYPAD_PERIOD; + case SDLK_KP_MULTIPLY: return SkaInputKey_KEYBOARD_KEYPAD_MULTIPLY; + case SDLK_KP_MINUS: return SkaInputKey_KEYBOARD_KEYPAD_MINUS; + case SDLK_KP_PLUS: return SkaInputKey_KEYBOARD_KEYPAD_PLUS; + case SDLK_KP_ENTER: return SkaInputKey_KEYBOARD_KEYPAD_ENTER; + case SDLK_KP_EQUALS: return SkaInputKey_KEYBOARD_KEYPAD_EQUALS; + case SDLK_LCTRL: return SkaInputKey_KEYBOARD_LEFT_CONTROL; + case SDLK_LSHIFT: return SkaInputKey_KEYBOARD_LEFT_SHIFT; + case SDLK_LALT: return SkaInputKey_KEYBOARD_LEFT_ALT; + case SDLK_LGUI: return SkaInputKey_KEYBOARD_LEFT_GUI; + case SDLK_RCTRL: return SkaInputKey_KEYBOARD_RIGHT_CONTROL; + case SDLK_RSHIFT: return SkaInputKey_KEYBOARD_RIGHT_SHIFT; + case SDLK_RALT: return SkaInputKey_KEYBOARD_RIGHT_ALT; + case SDLK_RGUI: return SkaInputKey_KEYBOARD_RIGHT_GUI; + case SDLK_APPLICATION: return SkaInputKey_KEYBOARD_APPLICATION; + case SDLK_0: return SkaInputKey_KEYBOARD_NUM_0; + case SDLK_1: return SkaInputKey_KEYBOARD_NUM_1; + case SDLK_2: return SkaInputKey_KEYBOARD_NUM_2; + case SDLK_3: return SkaInputKey_KEYBOARD_NUM_3; + case SDLK_4: return SkaInputKey_KEYBOARD_NUM_4; + case SDLK_5: return SkaInputKey_KEYBOARD_NUM_5; + case SDLK_6: return SkaInputKey_KEYBOARD_NUM_6; + case SDLK_7: return SkaInputKey_KEYBOARD_NUM_7; + case SDLK_8: return SkaInputKey_KEYBOARD_NUM_8; + case SDLK_9: return SkaInputKey_KEYBOARD_NUM_9; + case SDLK_a: return SkaInputKey_KEYBOARD_A; + case SDLK_b: return SkaInputKey_KEYBOARD_B; + case SDLK_c: return SkaInputKey_KEYBOARD_C; + case SDLK_d: return SkaInputKey_KEYBOARD_D; + case SDLK_e: return SkaInputKey_KEYBOARD_E; + case SDLK_f: return SkaInputKey_KEYBOARD_F; + case SDLK_g: return SkaInputKey_KEYBOARD_G; + case SDLK_h: return SkaInputKey_KEYBOARD_H; + case SDLK_i: return SkaInputKey_KEYBOARD_I; + case SDLK_j: return SkaInputKey_KEYBOARD_J; + case SDLK_k: return SkaInputKey_KEYBOARD_K; + case SDLK_l: return SkaInputKey_KEYBOARD_L; + case SDLK_m: return SkaInputKey_KEYBOARD_M; + case SDLK_n: return SkaInputKey_KEYBOARD_N; + case SDLK_o: return SkaInputKey_KEYBOARD_O; + case SDLK_p: return SkaInputKey_KEYBOARD_P; + case SDLK_q: return SkaInputKey_KEYBOARD_Q; + case SDLK_r: return SkaInputKey_KEYBOARD_R; + case SDLK_s: return SkaInputKey_KEYBOARD_S; + case SDLK_t: return SkaInputKey_KEYBOARD_T; + case SDLK_u: return SkaInputKey_KEYBOARD_U; + case SDLK_v: return SkaInputKey_KEYBOARD_V; + case SDLK_w: return SkaInputKey_KEYBOARD_W; + case SDLK_x: return SkaInputKey_KEYBOARD_X; + case SDLK_y: return SkaInputKey_KEYBOARD_Y; + case SDLK_z: return SkaInputKey_KEYBOARD_Z; + case SDLK_F1: return SkaInputKey_KEYBOARD_F1; + case SDLK_F2: return SkaInputKey_KEYBOARD_F2; + case SDLK_F3: return SkaInputKey_KEYBOARD_F3; + case SDLK_F4: return SkaInputKey_KEYBOARD_F4; + case SDLK_F5: return SkaInputKey_KEYBOARD_F5; + case SDLK_F6: return SkaInputKey_KEYBOARD_F6; + case SDLK_F7: return SkaInputKey_KEYBOARD_F7; + case SDLK_F8: return SkaInputKey_KEYBOARD_F8; + case SDLK_F9: return SkaInputKey_KEYBOARD_F9; + case SDLK_F10: return SkaInputKey_KEYBOARD_F10; + case SDLK_F11: return SkaInputKey_KEYBOARD_F11; + case SDLK_F12: return SkaInputKey_KEYBOARD_F12; + case SDLK_F13: return SkaInputKey_KEYBOARD_F13; + case SDLK_F14: return SkaInputKey_KEYBOARD_F14; + case SDLK_F15: return SkaInputKey_KEYBOARD_F15; + case SDLK_F16: return SkaInputKey_KEYBOARD_F16; + case SDLK_F17: return SkaInputKey_KEYBOARD_F17; + case SDLK_F18: return SkaInputKey_KEYBOARD_F18; + case SDLK_F19: return SkaInputKey_KEYBOARD_F19; + case SDLK_F20: return SkaInputKey_KEYBOARD_F20; + case SDLK_F21: return SkaInputKey_KEYBOARD_F21; + case SDLK_F22: return SkaInputKey_KEYBOARD_F22; + case SDLK_F23: return SkaInputKey_KEYBOARD_F23; + case SDLK_F24: return SkaInputKey_KEYBOARD_F24; + case SDLK_AC_BACK: return SkaInputKey_KEYBOARD_APP_BACK; + case SDLK_AC_FORWARD: return SkaInputKey_KEYBOARD_APP_FORWARD; + default: return SkaInputKey_INVALID; + } +} + + +SkaInputKey ska_sdl_mouse_button_to_input_key(SDL_MouseButtonEvent button) { + switch (button.button) { + case SDL_BUTTON_LEFT: return SkaInputKey_MOUSE_BUTTON_LEFT; + case SDL_BUTTON_RIGHT: return SkaInputKey_MOUSE_BUTTON_RIGHT; + case SDL_BUTTON_MIDDLE: return SkaInputKey_MOUSE_BUTTON_MIDDLE; + default: return SkaInputKey_INVALID; + } +} + +SkaInputKey ska_sdl_gamepad_button_to_input_key(SDL_GamepadButton button) { + switch (button) { + case SDL_GAMEPAD_BUTTON_SOUTH: return SkaInputKey_GAMEPAD_FACE_BUTTON_SOUTH; + case SDL_GAMEPAD_BUTTON_EAST: return SkaInputKey_GAMEPAD_FACE_BUTTON_EAST; + case SDL_GAMEPAD_BUTTON_WEST: return SkaInputKey_GAMEPAD_FACE_BUTTON_WEST; + case SDL_GAMEPAD_BUTTON_NORTH: return SkaInputKey_GAMEPAD_FACE_BUTTON_NORTH; + case SDL_GAMEPAD_BUTTON_BACK: return SkaInputKey_GAMEPAD_BACK; + case SDL_GAMEPAD_BUTTON_START: return SkaInputKey_GAMEPAD_START; + case SDL_GAMEPAD_BUTTON_LEFT_STICK: return SkaInputKey_GAMEPAD_LEFT_ANALOG_BUTTON; + case SDL_GAMEPAD_BUTTON_RIGHT_STICK: return SkaInputKey_GAMEPAD_RIGHT_ANALOG_BUTTON; + case SDL_GAMEPAD_BUTTON_LEFT_SHOULDER: return SkaInputKey_GAMEPAD_LEFT_SHOULDER; + case SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER: return SkaInputKey_GAMEPAD_RIGHT_SHOULDER; + case SDL_GAMEPAD_BUTTON_DPAD_UP: return SkaInputKey_GAMEPAD_DPAD_UP; + case SDL_GAMEPAD_BUTTON_DPAD_DOWN: return SkaInputKey_GAMEPAD_DPAD_DOWN; + case SDL_GAMEPAD_BUTTON_DPAD_LEFT: return SkaInputKey_GAMEPAD_DPAD_LEFT; + case SDL_GAMEPAD_BUTTON_DPAD_RIGHT: return SkaInputKey_GAMEPAD_DPAD_RIGHT; + default: return SkaInputKey_INVALID; + } +} + +SkaInputKey ska_sdl_gamepad_axis_to_input_key(SDL_GamepadAxis axis) { + switch (axis) { + case SDL_GAMEPAD_AXIS_LEFTX: return SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X; + case SDL_GAMEPAD_AXIS_LEFTY: return SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y; + case SDL_GAMEPAD_AXIS_RIGHTX: return SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X; + case SDL_GAMEPAD_AXIS_RIGHTY: return SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_Y; + case SDL_GAMEPAD_AXIS_LEFT_TRIGGER: return SkaInputKey_GAMEPAD_LEFT_TRIGGER; + case SDL_GAMEPAD_AXIS_RIGHT_TRIGGER: return SkaInputKey_GAMEPAD_RIGHT_TRIGGER; + default: return SkaInputKey_INVALID; + } +} + +bool ska_sdl_load_gamepad_mappings() { + const int loadResult = SDL_AddGamepadMapping(SKA_GAMEPAD_DB_STR); + return loadResult >= 0; +} + +static inline void ska_sdl_notify_input_event(const SkaSDLInputEvent* inputEvent) { + ska_input_register_input_event(inputEvent->sourceType, inputEvent->key, inputEvent->triggerType, inputEvent->deviceIndex, inputEvent->axisMotionValue); +} + +void ska_sdl_process_event(SDL_Event event) { + SkaSDLInputEvent inputEvent = { + .sourceType = SkaInputSourceType_INVALID, + .triggerType = SkaInputTriggerType_INVALID, + .deviceIndex = SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, + .key = SkaInputKey_INVALID, + .axisMotionValue = 0.0f + }; + + switch (event.type) { + // Mouse + case SDL_EVENT_MOUSE_MOTION: { + SkaMouse* mouse = ska_input_get_mouse(); + mouse->position = (SkaVector2){ .x = (f32)event.motion.x, .y = (f32)event.motion.y }; + break; + } + + case SDL_EVENT_MOUSE_BUTTON_DOWN: + case SDL_EVENT_MOUSE_BUTTON_UP: { + inputEvent.sourceType = SkaInputSourceType_MOUSE; + inputEvent.triggerType = event.type == SDL_EVENT_MOUSE_BUTTON_DOWN ? SkaInputTriggerType_PRESSED : SkaInputTriggerType_RELEASED; + inputEvent.key = ska_sdl_mouse_button_to_input_key(event.button); + break; + } + // Keyboard + case SDL_EVENT_KEY_DOWN: + case SDL_EVENT_KEY_UP: { + inputEvent.sourceType = SkaInputSourceType_KEYBOARD; + inputEvent.triggerType = event.type == SDL_EVENT_KEY_DOWN ? SkaInputTriggerType_PRESSED : SkaInputTriggerType_RELEASED, + inputEvent.key = ska_sdl_keycode_to_input_key(event.key.keysym.sym); + break; + } + // Gamepad + case SDL_EVENT_GAMEPAD_ADDED: { + const SDL_JoystickID deviceIndex = event.gdevice.which; + SDL_Gamepad* newGamepad = SDL_OpenGamepad(deviceIndex); + const int playerIndex = SDL_GetGamepadPlayerIndex(newGamepad); + const SkaSDLGamepadData newGamepadData = { .gamepad = newGamepad, .deviceIndex = playerIndex }; + gamepadData[deviceIndex] = newGamepadData; + gamepadDataByPlayerIndex[playerIndex] = newGamepadData; + activeGamepads++; + + inputEvent.sourceType = SkaInputSourceType_GAMEPAD; + inputEvent.triggerType = SkaInputTriggerType_DEVICE_ADDED; + inputEvent.deviceIndex = playerIndex; + break; + } + case SDL_EVENT_GAMEPAD_REMOVED: { + const SDL_JoystickID deviceIndex = event.gdevice.which; + SDL_Gamepad* removedGamepad = gamepadData[deviceIndex].gamepad; + const SkaInputDeviceIndex playerIndex = gamepadData[deviceIndex].deviceIndex; + SDL_CloseGamepad(removedGamepad); + const SkaSDLGamepadData defaultGamepadData = (SkaSDLGamepadData){ .gamepad = NULL, .deviceIndex = -1 }; + gamepadData[deviceIndex] = defaultGamepadData; + gamepadDataByPlayerIndex[playerIndex] = defaultGamepadData; + activeGamepads--; + + inputEvent.sourceType = SkaInputSourceType_GAMEPAD; + inputEvent.triggerType = SkaInputTriggerType_DEVICE_REMOVED; + inputEvent.deviceIndex = playerIndex; + break; + } + case SDL_EVENT_GAMEPAD_BUTTON_DOWN: + case SDL_EVENT_GAMEPAD_BUTTON_UP: { + const SDL_JoystickID deviceIndex = event.jbutton.which; + const SkaInputDeviceIndex playerIndex = gamepadData[deviceIndex].deviceIndex; + const bool isButtonPressed = event.jbutton.state == SDL_PRESSED; + const SDL_GamepadButton buttonValue = event.jbutton.button; + + inputEvent.sourceType = SkaInputSourceType_GAMEPAD; + inputEvent.triggerType = isButtonPressed ? SkaInputTriggerType_PRESSED : SkaInputTriggerType_RELEASED; + inputEvent.deviceIndex = playerIndex; + inputEvent.key = ska_sdl_gamepad_button_to_input_key(buttonValue); + break; + } + default: + break; + } + ska_sdl_notify_input_event(&inputEvent); +} + +// Call after looping through all sdl input events for a frame +void ska_sdl_process_axis_events() { +#define SKA_SDL_GAMEPAD_AXIS_DEAD_ZONE 8000 +#define SKA_MAX_AXIS_VALUES 6 + + static const SDL_GamepadAxis AXIS_KEYS[SKA_MAX_AXIS_VALUES] = { + SDL_GAMEPAD_AXIS_LEFTX, SDL_GAMEPAD_AXIS_LEFTY, + SDL_GAMEPAD_AXIS_RIGHTX, SDL_GAMEPAD_AXIS_RIGHTY, + SDL_GAMEPAD_AXIS_LEFT_TRIGGER, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER + }; + static bool hasGamepadStoppedAxisMotion[SKA_INPUT_MAX_DEVICES][SKA_MAX_AXIS_VALUES] = { + {true, true, true, true, true, true}, + {true, true, true, true, true, true}, + {true, true, true, true, true, true}, + {true, true, true, true, true, true}, + {true, true, true, true, true, true}, + {true, true, true, true, true, true}, + {true, true, true, true, true, true}, + {true, true, true, true, true, true} + }; + + for (uint32 i = 0; i < activeGamepads; i++) { + SkaSDLGamepadData* currentGamepadData = &gamepadDataByPlayerIndex[i]; + for (SDL_GamepadAxis axis = 0; axis < SKA_MAX_AXIS_VALUES; axis++) { + const int16 axisValue = SDL_GetGamepadAxis(currentGamepadData->gamepad, axis); + const SkaInputTriggerType triggerType = + axisValue < SKA_SDL_GAMEPAD_AXIS_DEAD_ZONE && axisValue > -SKA_SDL_GAMEPAD_AXIS_DEAD_ZONE + ? SkaInputTriggerType_AXIS_STOPPED_MOTION : SkaInputTriggerType_AXIS_IN_MOTION; + // Skip sending event if axis motion is already stopped + bool *hasStoppedAxisMotion = &hasGamepadStoppedAxisMotion[i][axis]; + if (triggerType == SkaInputTriggerType_AXIS_STOPPED_MOTION) { + if (*hasStoppedAxisMotion) { + continue; + } else { + *hasStoppedAxisMotion = true; + } + } else { + *hasStoppedAxisMotion = false; + } + const f32 axisValueNormalized = ska_math_map_to_range((f32) axisValue, (f32) INT16_MIN, (f32) INT16_MAX,-1.0f, 1.0f); + const SkaSDLInputEvent inputEvent = { + .sourceType = SkaInputSourceType_GAMEPAD, + .triggerType = triggerType, + .deviceIndex = (SkaInputDeviceIndex)i, + .key = ska_sdl_gamepad_axis_to_input_key(axis), + .axisMotionValue = axisValueNormalized + }; + ska_sdl_notify_input_event(&inputEvent); + } + } + +#undef SKA_MAX_AXIS_VALUES +} + +#endif // if SKA_INPUT diff --git a/test/test1.c b/test/test1.c index 09df0e3..d0d910d 100644 --- a/test/test1.c +++ b/test/test1.c @@ -11,6 +11,10 @@ #include "seika/ecs/ec_system.h" #endif +#if SKA_INPUT +#include "seika/input/input.h" +#endif + #define RESOURCES_PATH "test/resources" #define RESOURCES_PACK_PATH "test/resources/test.pck" @@ -25,6 +29,10 @@ void seika_id_queue_test(void); void seika_ecs_test(void); #endif +#if SKA_INPUT +void seika_input_test(void); +#endif + int32 main(int32 argv, char** args) { UNITY_BEGIN(); RUN_TEST(seika_mem_test); @@ -32,6 +40,9 @@ int32 main(int32 argv, char** args) { RUN_TEST(seika_id_queue_test); #if SKA_ECS RUN_TEST(seika_ecs_test); +#endif +#if SKA_INPUT + RUN_TEST(seika_input_test); #endif return UNITY_END(); } @@ -198,3 +209,92 @@ void seika_ecs_test(void) { ska_ecs_finalize(); } #endif + +#if SKA_INPUT + +void seika_input_test(void) { + TEST_MESSAGE("Testing 'for each' and checking input type"); + SKA_INPUT_KEY_GAMEPAD_FOR_EACH(key) { + TEST_ASSERT_TRUE(ska_input_is_gamepad_key(key)); + } + SKA_INPUT_KEY_KEYBOARD_FOR_EACH(key) { + TEST_ASSERT_TRUE(ska_input_is_keyboard_key(key)); + } + SKA_INPUT_KEY_MOUSE_FOR_EACH(key) { + TEST_ASSERT_TRUE(ska_input_is_mouse_key(key)); + } + + const char* backspaceKeyName = ska_input_key_to_string(SkaInputKey_KEYBOARD_BACKSPACE); + const SkaInputKey backSpaceKey = ska_input_string_to_key(backspaceKeyName); + TEST_ASSERT_EQUAL_STRING("Backspace", backspaceKeyName); + TEST_ASSERT_EQUAL_INT(SkaInputKey_KEYBOARD_BACKSPACE, backSpaceKey); + + TEST_MESSAGE("Testing events"); + ska_input_register_input_event3(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_BACKSPACE, SkaInputTriggerType_PRESSED); + TEST_ASSERT_TRUE(ska_input_is_key_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_TRUE(ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_key_just_released(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + + ska_input_register_input_event3(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_BACKSPACE, SkaInputTriggerType_PRESSED); + TEST_ASSERT_TRUE(ska_input_is_key_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_key_just_released(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + + ska_input_register_input_event3(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_BACKSPACE, SkaInputTriggerType_RELEASED); + TEST_ASSERT_FALSE(ska_input_is_key_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_TRUE(ska_input_is_key_just_released(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + + TEST_MESSAGE("Testing input get axis input"); + ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y, SkaInputTriggerType_AXIS_IN_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, -0.5f); + const SkaVector2 firstAxisInput = ska_input_get_axis_input(SkaInputAxis_LEFT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); + TEST_ASSERT_EQUAL_FLOAT(0.0f, firstAxisInput.x); + TEST_ASSERT_EQUAL_FLOAT(-0.5f, firstAxisInput.y); + + ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X, SkaInputTriggerType_AXIS_IN_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.25f); + const SkaVector2 secondAxisInput = ska_input_get_axis_input(SkaInputAxis_LEFT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); + TEST_ASSERT_EQUAL_FLOAT(0.25f, secondAxisInput.x); + TEST_ASSERT_EQUAL_FLOAT(-0.5f, secondAxisInput.y); + + ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X, SkaInputTriggerType_AXIS_STOPPED_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.25f); + ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y, SkaInputTriggerType_AXIS_STOPPED_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.25f); + const SkaVector2 thirdAxisInput = ska_input_get_axis_input(SkaInputAxis_LEFT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); + TEST_ASSERT_EQUAL_FLOAT(0.0f, thirdAxisInput.x); + TEST_ASSERT_EQUAL_FLOAT(0.0f, thirdAxisInput.y); + + ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X, SkaInputTriggerType_AXIS_IN_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 1.0f); + const SkaVector2 fourthAxisInput = ska_input_get_axis_input(SkaInputAxis_RIGHT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); + TEST_ASSERT_EQUAL_FLOAT(1.0f, fourthAxisInput.x); + TEST_ASSERT_EQUAL_FLOAT(0.0f, fourthAxisInput.y); + + TEST_MESSAGE("Testing input actions"); + SkaInputActionHandle jumpActionHandle = ska_input_add_input_action( + "jump", + (SkaInputActionValue[]){ { .key = SkaInputKey_KEYBOARD_SPACE, .strengthThreshold = 0.5f }, { .key = SkaInputKey_KEYBOARD_RETURN, .strengthThreshold = 0.5f }, { SkaInputKey_INVALID } }, + SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX + ); + TEST_ASSERT_NOT_EQUAL_UINT32(SKA_INPUT_INVALID_INPUT_ACTION_HANDLE, jumpActionHandle); + jumpActionHandle = ska_input_find_input_action_handle("jump", SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); + TEST_ASSERT_NOT_EQUAL_UINT32(SKA_INPUT_INVALID_INPUT_ACTION_HANDLE, jumpActionHandle); + + ska_input_register_input_event(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_RETURN, SkaInputTriggerType_PRESSED, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.0f); + TEST_ASSERT_TRUE(ska_input_is_input_action_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_TRUE(ska_input_is_input_action_just_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_input_action_just_released(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_EQUAL_FLOAT(1.0f, ska_input_get_input_action_strength(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + + ska_input_new_frame(); + TEST_ASSERT_TRUE(ska_input_is_input_action_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_input_action_just_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_input_action_just_released(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + + ska_input_register_input_event(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_RETURN, SkaInputTriggerType_RELEASED, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.0f); + TEST_ASSERT_FALSE(ska_input_is_input_action_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_input_action_just_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_TRUE(ska_input_is_input_action_just_released(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + + ska_input_remove_input_action(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); + TEST_ASSERT_EQUAL_UINT32(SKA_INPUT_INVALID_INPUT_ACTION_HANDLE, ska_input_find_input_action_handle("jump", SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); +} + +#endif // if SKA_INPUT From 1f37cee66dea211387840a03297501b43588a4dd Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 17 Oct 2024 23:11:24 -0400 Subject: [PATCH 21/55] Clean. --- Dependencies.cmake | 6 +++--- seika/CMakeLists.txt | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/Dependencies.cmake b/Dependencies.cmake index e18bfa9..1f7f622 100644 --- a/Dependencies.cmake +++ b/Dependencies.cmake @@ -36,7 +36,7 @@ if (NOT TARGET unity) FetchContent_MakeAvailable(unity_content) endif() -if (SEIKA_ENABLE_INPUT) +if (SEIKA_INPUT) # https://github.com/libsdl-org/SDL if (NOT TARGET SDL3::SDL3-static) set(SDL_STATIC ${SEIKA_STATIC_LIB}) @@ -57,7 +57,7 @@ if (SEIKA_ENABLE_INPUT) endif () endif() -if (SEIKA_ENABLE_RENDERING) +if (SEIKA_RENDERING) # https://github.com/Dav1dde/glad if (NOT TARGET glad) if (SEIKA_STATIC_LIB) @@ -93,7 +93,7 @@ if (SEIKA_ENABLE_RENDERING) endif() endif() -if (SEIKA_ENABLE_AUDIO) +if (SEIKA_AUDIO) # https://github.com/mackron/miniaudio if (NOT TARGET miniaudio) add_library(miniaudio INTERFACE thirdparty/miniaudio/miniaudio.h) diff --git a/seika/CMakeLists.txt b/seika/CMakeLists.txt index dec5c19..179c481 100644 --- a/seika/CMakeLists.txt +++ b/seika/CMakeLists.txt @@ -20,15 +20,15 @@ target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/.. set(LIBS_TO_LINK "") -if (SEIKA_ENABLE_RENDERING) +if (SEIKA_RENDERING) list(APPEND LIBS_TO_LINK glad stb_image freetype) endif() -if (SEIKA_ENABLE_AUDIO) +if (SEIKA_AUDIO) list(APPEND LIBS_TO_LINK miniaudio) endif() -if (SEIKA_ENABLE_INPUT) +if (SEIKA_INPUT) list(APPEND LIBS_TO_LINK ${SDL3_LIBRARY}) endif() From cd7179541b3e222a89d80d14f8e13dbef5a0b1b5 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 17 Oct 2024 23:13:23 -0400 Subject: [PATCH 22/55] Clean. --- CMakeLists.txt | 8 -------- 1 file changed, 8 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 0ad0eb8..1e985eb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -20,13 +20,6 @@ add_compile_definitions(SKA_INPUT=$,1,0>) add_compile_definitions(SKA_RENDERING=$,1,0>) add_compile_definitions(SKA_AUDIO=$,1,0>) -function(set_common_compile_definitions target) - target_compile_definitions(${target} PRIVATE SKA_ECS=$,1,0>) - target_compile_definitions(${target} PRIVATE SKA_INPUT=$,1,0>) - target_compile_definitions(${target} PRIVATE SKA_RENDERING=$,1,0>) - target_compile_definitions(${target} PRIVATE SKA_AUDIO=$,1,0>) -endfunction() - set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) @@ -56,6 +49,5 @@ if (SK_IS_MAIN) # Create seika1 test exe add_executable(seika1_test test/test1.c) target_link_libraries(seika1_test seika1 unity) - set_common_compile_definitions(seika1_test) endif() endif() From cd047eda1580c0eee06e8390aff7bc8b3998c31b Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 17 Oct 2024 23:22:19 -0400 Subject: [PATCH 23/55] Updates. --- CMakeLists.txt | 2 +- seika/networking/network.c | 143 +++++++++++++++++ seika/networking/network.h | 24 +++ seika/networking/network_socket.c | 126 +++++++++++++++ seika/networking/network_socket.h | 43 +++++ seika/thread/pthread.c | 255 ++++++++++++++++++++++++++++++ seika/thread/pthread.h | 63 ++++++++ seika/thread/thread_pool.c | 184 +++++++++++++++++++++ seika/thread/thread_pool.h | 32 ++++ 9 files changed, 871 insertions(+), 1 deletion(-) create mode 100644 seika/networking/network.c create mode 100644 seika/networking/network.h create mode 100644 seika/networking/network_socket.c create mode 100644 seika/networking/network_socket.h create mode 100644 seika/thread/pthread.c create mode 100644 seika/thread/pthread.h create mode 100644 seika/thread/thread_pool.c create mode 100644 seika/thread/thread_pool.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 1e985eb..6f8d307 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -9,7 +9,7 @@ option(SEIKA_STATIC_LIB "Make seika and dependent libs static" OFF) option(SEIKA_ENABLE_OLD "Will build old seika lib" OFF) option(SEIKA_ENABLE_1 "Will build new seika lib" ON) -# Compilation Modes +# Optional Modules option(SEIKA_ECS "Will enable ecs" ON) option(SEIKA_INPUT "Will enable input" ON) option(SEIKA_RENDERING "Will enable rendering" OFF) diff --git a/seika/networking/network.c b/seika/networking/network.c new file mode 100644 index 0000000..0d6a6ab --- /dev/null +++ b/seika/networking/network.c @@ -0,0 +1,143 @@ +#include "network.h" + +#include +#include + +#include "network_socket.h" +#include "seika/logger.h" +#include "seika/assert.h" + +//--- NETWORK ---// +#define SKA_NETWORK_HANDSHAKE_MESSAGE "init" + +static bool ska_is_server = false; + +bool ska_network_is_server() { + return ska_is_server; +} + +//--- UDP SERVER ---// +#define SKA_SERVER_BUFFER_SIZE 512 + +static void* ska_udp_server_poll(void* arg); + +static ska_on_network_server_callback server_user_callback = NULL; +static ska_on_network_server_client_connected_callback server_client_connected_callback = NULL; + +static SkaSocket server_socket; + +bool ska_udp_server_initialize(int32 port, ska_on_network_server_callback user_callback) { + server_user_callback = user_callback; + ska_socket_system_initialize(); + server_socket = ska_socket_create_server(port, ska_udp_server_poll); + ska_is_server = true; + + return true; +} + +void ska_udp_server_register_client_connected_callback(ska_on_network_server_client_connected_callback client_connected_callback) { + server_client_connected_callback = client_connected_callback; +} + +void* ska_udp_server_poll(void* arg) { + static char server_input_buffer[SKA_SERVER_BUFFER_SIZE]; + //keep listening for data + while (true) { + fflush(stdout); + + //clear the buffer by filling null, it might have previously received data + memset(server_input_buffer, '\0', SKA_SERVER_BUFFER_SIZE); + //try to receive some data, this is a blocking call + if (!ska_socket_receive_data(&server_socket, server_input_buffer, SKA_SERVER_BUFFER_SIZE)) { + ska_logger_error("Failed to receive socket data with server!"); +// return NULL; + continue; + } + + // Process data from client + if (strcmp(server_input_buffer, SKA_NETWORK_HANDSHAKE_MESSAGE) == 0) { + if (server_client_connected_callback != NULL) { + server_client_connected_callback(); + } + ska_udp_server_send_message(SKA_NETWORK_HANDSHAKE_MESSAGE); + } else { + // Call user callback + server_user_callback(server_input_buffer); + } + } + return NULL; +} + +bool ska_udp_server_send_message(const char* message) { + if (!ska_socket_send_message(&server_socket, message)) { + ska_logger_error("Failed to send message '%s'", message); + return false; + } + return true; +} + +void ska_udp_server_finalize() { + ska_socket_close(&server_socket); + ska_socket_system_finalize(); +} + +//--- UDP CLIENT ---// +#define SKA_CLIENT_BUFFER_SIZE 512 + +static void* ska_udp_client_poll(void*); + +static SkaSocket client_socket; +static ska_on_network_client_callback client_user_callback = NULL; + +bool ska_udp_client_initialize(const char* serverAddr, int32 serverPort, ska_on_network_client_callback user_callback) { + client_user_callback = user_callback; + ska_socket_system_initialize(); + client_socket = ska_socket_create_client(serverAddr, serverPort, ska_udp_client_poll); + ska_logger_debug("Client: Initialized thread."); + + return true; +} + +void* ska_udp_client_poll(void *unused) { + static char client_input_buffer[SKA_CLIENT_BUFFER_SIZE]; + // TODO: Do handshake + // TODO: Figure out why there is failure if no message is sent at first + ska_socket_send_message(&client_socket, SKA_NETWORK_HANDSHAKE_MESSAGE); + + while (true) { + fflush(stdout); + //clear the buffer by filling null, it might have previously received data + memset(client_input_buffer, '\0', SKA_CLIENT_BUFFER_SIZE); + //try to receive some data, this is a blocking call + if (!ska_socket_receive_data(&client_socket, client_input_buffer, SKA_CLIENT_BUFFER_SIZE)) { + ska_logger_error("Failed to receive socket data from client!"); +// RBE_ASSERT(false); + continue; + } + + if (strcmp(client_input_buffer, SKA_NETWORK_HANDSHAKE_MESSAGE) == 0) { + if (server_client_connected_callback != NULL) { + server_client_connected_callback(); + } + } else { + // Call user callback + client_user_callback(client_input_buffer); + } + } + + return NULL; +} + +bool ska_udp_client_send_message(const char* message) { + if (!ska_socket_send_message(&client_socket, message)) { + ska_logger_error("Failed to send message '%s'", message); + return false; + } + + return true; +} + +void ska_udp_client_finalize() { + ska_socket_close(&client_socket); + ska_socket_system_finalize(); +} diff --git a/seika/networking/network.h b/seika/networking/network.h new file mode 100644 index 0000000..dedf863 --- /dev/null +++ b/seika/networking/network.h @@ -0,0 +1,24 @@ +#pragma once + +#include + +#include "seika/defines.h" + +//--- NETWORK ---// +bool ska_network_is_server(); + +//--- UDP SERVER ---// +typedef void (*ska_on_network_server_callback) (const char*); +typedef void (*ska_on_network_server_client_connected_callback) (); + +bool ska_udp_server_initialize(int32 port, ska_on_network_server_callback user_callback); +void ska_udp_server_register_client_connected_callback(ska_on_network_server_client_connected_callback client_connected_callback); +bool ska_udp_server_send_message(const char* message); +void ska_udp_server_finalize(); + +//--- UDP CLIENT ---// +typedef void (*ska_on_network_client_callback) (const char*); + +bool ska_udp_client_initialize(const char* serverAddr, int32 serverPort, ska_on_network_client_callback user_callback); +bool ska_udp_client_send_message(const char* message); +void ska_udp_client_finalize(); diff --git a/seika/networking/network_socket.c b/seika/networking/network_socket.c new file mode 100644 index 0000000..6828cab --- /dev/null +++ b/seika/networking/network_socket.c @@ -0,0 +1,126 @@ +#include "network_socket.h" + +#include + +#include "seika/logger.h" +#include "seika/assert.h" +#include "seika/string.h" +#include "seika/thread/pthread.h" + +//--- RBE Socket ---// +static int ska_socket_get_last_error() { +#ifdef _WIN32 + return WSAGetLastError(); +#else + return -1; +#endif +} + +bool ska_socket_system_initialize() { +#ifdef _WIN32 + // Initialise winsock + WSADATA wsa; + ska_logger_debug("Initialising client Winsock..."); + if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) { + ska_logger_error("Client: Failed. Error Code : %d", ska_socket_get_last_error()); + return false; + } + ska_logger_debug("Client: Initialized Winsock."); +#endif + return true; +} + +void ska_socket_system_finalize() { +#ifdef _WIN32 + WSACleanup(); +#endif +} + +bool ska_socket_send_message(SkaSocket* sock, const char* message) { +#define CRE_SOCKET_SEND_BUFFER_SIZE 512 + static char socket_output_buffer[CRE_SOCKET_SEND_BUFFER_SIZE]; + ska_strcpy(socket_output_buffer, message); + if (sendto(sock->sock, socket_output_buffer, (int) strlen(socket_output_buffer), 0, (struct sockaddr*) &sock->si_other, sock->size) == SOCKET_ERROR) { + ska_logger_error("sendto() failed with error code : %d", ska_socket_get_last_error()); + return false; + } + return true; +#undef CRE_SOCKET_SEND_BUFFER_SIZE +} + +bool ska_socket_receive_data(SkaSocket* sock, char* buffer, int32 buffer_size) { + if ((recvfrom(sock->sock, buffer, buffer_size, 0, (struct sockaddr*) &sock->si_other, &sock->size)) == SOCKET_ERROR) { + ska_logger_error("recvfrom() failed with error code : %d", ska_socket_get_last_error()); + return false; + } + return true; +} + +void ska_socket_close(SkaSocket* sock) {} + +//--- Server Socker ---// +static pthread_t server_thread; + +SkaSocket ska_socket_create_server(int32 port, ska_on_socket_receive_data callback_func) { + SKA_ASSERT_FMT(callback_func, "Callback func is NULL"); + SkaSocket sock; + sock.size = sizeof(sock.si_other); + + // Create a socket + if ((sock.sock = socket(AF_INET, SOCK_DGRAM, 0 )) == INVALID_SOCKET) { + SKA_ASSERT_FMT(false, "Server: could not create socket : %d", ska_socket_get_last_error()); + } + ska_logger_debug("Server: socket created!"); + + // Prepare the sockaddr_in structure + sock.si.sin_family = AF_INET; + sock.si.sin_addr.s_addr = INADDR_ANY; + sock.si.sin_port = htons(port); + + // Bind + if (bind(sock.sock, (struct sockaddr *) &sock.si, sizeof(sock.si)) == SOCKET_ERROR) { + SKA_ASSERT_FMT(false, "Server: Bind failed with error code : %d", ska_socket_get_last_error()); + } + ska_logger_debug("Server: Bind done!"); + + // Start Networking Thread + if (pthread_create(&server_thread, NULL, callback_func, NULL) != 0) { + SKA_ASSERT_FMT(false, "Failed to create server thread!"); + } + ska_logger_debug("Server: Initialized thread."); + return sock; +} + +//--- Client Socket ---// +static pthread_t client_thread; + +SkaSocket ska_socket_create_client(const char* serverAddr, int32 serverPort, ska_on_socket_receive_data callback_func) { + //create socket + SkaSocket sock; + sock.size = sizeof(sock.si_other); + ska_logger_debug("Client: Creating socket...."); + if ((int) (sock.sock = (int) socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == SOCKET_ERROR) { + SKA_ASSERT_FMT(false, "Client: socket() failed with error code : %d", ska_socket_get_last_error()); + } + ska_logger_debug("Client: socket created."); + + // setup address structure + memset((char*) &sock.si_other, 0, sizeof(sock.si_other)); + sock.si_other.sin_family = AF_INET; + sock.si_other.sin_port = htons(serverPort); +#ifdef _WIN32 + sock.si_other.sin_addr.S_un.S_addr = inet_addr(serverAddr); +#else + if (inet_aton(serverAddr, &sock.si_other.sin_addr) == 0) { + SKA_ASSERT_FMT(false, "inet_aton() failed!"); + } +#endif + + // Start Networking Thread + if (pthread_create(&client_thread, NULL, callback_func, NULL) != 0) { + SKA_ASSERT_FMT(false, "Failed to create server thread!"); + } + + ska_logger_debug("Client: Initialized thread."); + return sock; +} diff --git a/seika/networking/network_socket.h b/seika/networking/network_socket.h new file mode 100644 index 0000000..dcc2693 --- /dev/null +++ b/seika/networking/network_socket.h @@ -0,0 +1,43 @@ +#pragma once + +#include + +#include "seika/defines.h" + +#ifdef _WIN32 +#include + +typedef int32 se_socket_size; +typedef SOCKET ska_socket; +#else +#include +#include + +#define SOCKET_ERROR (-1) +#define INVALID_SOCKET (-1) + +typedef socklen_t se_socket_size; +typedef int ska_socket; +#endif + +//--- RBE Socket---// +typedef void* (*ska_on_socket_receive_data) (void*); + +typedef struct SkaSocket { + ska_socket sock; + se_socket_size size; + struct sockaddr_in si; + struct sockaddr_in si_other; +} SkaSocket; + +bool ska_socket_system_initialize(); +void ska_socket_system_finalize(); +bool ska_socket_send_message(SkaSocket* sock, const char* message); +bool ska_socket_receive_data(SkaSocket* sock, char* buffer, int32 buffer_size); +void ska_socket_close(SkaSocket* sock); + +//--- Server Socket ---// +SkaSocket ska_socket_create_server(int32 port, ska_on_socket_receive_data callback_func); + +//--- Client Socket ---// +SkaSocket ska_socket_create_client(const char* serverAddr, int32 serverPort, ska_on_socket_receive_data callback_func); diff --git a/seika/thread/pthread.c b/seika/thread/pthread.c new file mode 100644 index 0000000..69c998f --- /dev/null +++ b/seika/thread/pthread.c @@ -0,0 +1,255 @@ +#include "pthread.h" + +#ifdef _WIN32 +#include "seika/memory.h" + +typedef struct { + void* (*start_routine)(void*); + void* start_arg; +} win_thread_start_t; + +static DWORD WINAPI win_thread_start(void* arg); +static DWORD timespec_to_ms(const struct timespec *abstime); + +// --- General --- // +int pthread_create(pthread_t* thread, pthread_attr_t* attr, void* (*start_routine)(void*), void* arg) { + win_thread_start_t* data; + + (void) attr; + + if (thread == NULL || start_routine == NULL) { + return 1; // ERROR + } + + data = malloc(sizeof(*data)); + data->start_routine = start_routine; + data->start_arg = arg; + + *thread = CreateThread(NULL, 0, win_thread_start, data, 0, NULL); + if (*thread == NULL) { + return 1; // ERROR + } + return 0; // SUCCESS +} + +int pthread_join(pthread_t thread, void** value_ptr) { + (void) value_ptr; + WaitForSingleObject(thread, INFINITE); + CloseHandle(thread); + return 0; // SUCCESS +} + +int pthread_detach(pthread_t thread) { + // TODO: Process return value + CloseHandle(thread); + return 0; // SUCCESS +} + +int pthread_self() { + return (int) GetCurrentThreadId(); +} + +// --- Mutex --- // +int pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t *attr) { + (void)attr; + + if (mutex == NULL) { + return 1; // ERROR + } + + InitializeCriticalSection(mutex); + return 0; // SUCCESS +} + +int pthread_mutex_destroy(pthread_mutex_t *mutex) { + if (mutex == NULL) { + return 1; // ERROR + } + DeleteCriticalSection(mutex); + return 0; // SUCCESS +} + +int pthread_mutex_lock(pthread_mutex_t *mutex) { + if (mutex == NULL) { + return 1; // ERROR + } + EnterCriticalSection(mutex); + return 0; // SUCCESS +} + +int pthread_mutex_unlock(pthread_mutex_t *mutex) { + if (mutex == NULL) { + return 1; // ERROR + } + LeaveCriticalSection(mutex); + return 0; // SUCCESS +} + + +// --- Conditionals --- // +int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *attr) { + (void) attr; + if (cond == NULL) { + return 1; // ERROR + } + InitializeConditionVariable(cond); + return 0; // SUCCESS +} + +int pthread_cond_destroy(pthread_cond_t* cond) { + // Windows does not have a way to destroy conditionals + (void) cond; + return 0; // SUCCESS +} + +int pthread_cond_wait(pthread_cond_t* cond, pthread_mutex_t *mutex) { + if (cond == NULL || mutex == NULL) { + return 1; // ERROR + } + return pthread_cond_timedwait(cond, mutex, NULL); +} + +int pthread_cond_timedwait(pthread_cond_t* cond, pthread_mutex_t *mutex, const struct timespec *abstime) { + if (cond == NULL || mutex == NULL) { + return 1; // ERROR + } + if (!SleepConditionVariableCS(cond, mutex, timespec_to_ms(abstime))) { + return 1; // ERROR + } + return 0; // SUCCESS +} + +int pthread_cond_signal(pthread_cond_t* cond) { + if (cond == NULL) { + return 1; // ERROR + } + WakeConditionVariable(cond); + return 0; // SUCCESS +} + +int pthread_cond_broadcast(pthread_cond_t* cond) { + if (cond == NULL) { + return 1; // ERROR + } + WakeAllConditionVariable(cond); + return 0; // SUCCESS +} + +// --- Read Write Locks --- // +int pthread_rwlock_init(pthread_rwlock_t* rwlock, const pthread_rwlockattr_t* attr) { + (void) attr; + if (rwlock == NULL) { + return 1; + } + InitializeSRWLock(&(rwlock->lock)); + rwlock->exclusive = false; + return 0; +} + +int pthread_rwlock_destroy(pthread_rwlock_t* rwlock) { + (void) rwlock; + return 0; // SUCCESS +} + +int pthread_rwlock_rdlock(pthread_rwlock_t* rwlock) { + if (rwlock == NULL) { + return 1; // ERROR + } + AcquireSRWLockShared(&(rwlock->lock)); + return 0; // SUCCESS +} + +int pthread_rwlock_tryrdlock(pthread_rwlock_t* rwlock) { + if (rwlock == NULL) { + return 1; // ERROR + } + return !TryAcquireSRWLockShared(&(rwlock->lock)); +} + +int pthread_rwlock_wrlock(pthread_rwlock_t* rwlock) { + if (rwlock == NULL) { + return 1; // ERROR + } + AcquireSRWLockExclusive(&(rwlock->lock)); + rwlock->exclusive = true; + return 0; // SUCCESS +} + +int pthread_rwlock_trywrlock(pthread_rwlock_t* rwlock) { + BOOLEAN ret; + + if (rwlock == NULL) { + return 1; // ERROR + } + + ret = TryAcquireSRWLockExclusive(&(rwlock->lock)); + if (ret) { + rwlock->exclusive = true; + } + return ret; +} + +int pthread_rwlock_unlock(pthread_rwlock_t* rwlock) { + if (rwlock == NULL) { + return 1; // ERROR + } + + if (rwlock->exclusive) { + rwlock->exclusive = false; + ReleaseSRWLockExclusive(&(rwlock->lock)); + } else { + ReleaseSRWLockShared(&(rwlock->lock)); + } + return 0; // SUCCESS +} + + +// --- MISC --- // +static DWORD WINAPI win_thread_start(void* arg) { + win_thread_start_t* data = arg; + void* (*start_routine)(void*) = data->start_routine; + void* start_arg = data->start_arg; + + SKA_FREE(data); + + start_routine(start_arg); + return 0; // ERROR_SUCCESS +} + +static DWORD timespec_to_ms(const struct timespec *abstime) { + DWORD t; + + if (abstime == NULL) { + return INFINITE; + } + + t = (DWORD) (((abstime->tv_sec - time(NULL)) * 1000) + (abstime->tv_nsec / 1000000)); +// if (t < 0) { +// t = 1; +// } + return t; +} + +//#ifdef _WIN32 +unsigned int pcthread_get_num_procs() { + SYSTEM_INFO sysinfo; + + GetSystemInfo(&sysinfo); + return sysinfo.dwNumberOfProcessors; +} + +#else + +#include +unsigned int pcthread_get_num_procs() { + return (unsigned int)sysconf(_SC_NPROCESSORS_ONLN); +} +#endif + +void ms_to_timespec(struct timespec *ts, uint32 ms) { + if (ts == NULL) { + return; + } + ts->tv_sec = ((long) ms / 1000) + time(NULL); + ts->tv_nsec = ((long) ms % 1000) * 1000000; +} diff --git a/seika/thread/pthread.h b/seika/thread/pthread.h new file mode 100644 index 0000000..66dfafa --- /dev/null +++ b/seika/thread/pthread.h @@ -0,0 +1,63 @@ +#pragma once + +#ifdef _WIN32 +#include +#include +#include + +#else +#include +#endif + +#include "seika/defines.h" + +#ifdef _WIN32 +typedef CRITICAL_SECTION pthread_mutex_t; +typedef void pthread_mutexattr_t; +typedef void pthread_condattr_t; +typedef void pthread_rwlockattr_t; +typedef HANDLE pthread_t; +typedef CONDITION_VARIABLE pthread_cond_t; + +typedef struct { + SRWLOCK lock; + bool exclusive; +} pthread_rwlock_t; + +typedef struct { + int DUMMY_MEMBER; // FIXME: this is only here because of: 'error C2016: C requires that a struct or union have at least one member' +} pthread_attr_t; + +#endif + +#ifdef _WIN32 +int pthread_create(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *arg); +int pthread_join(pthread_t thread, void **value_ptr); +int pthread_detach(pthread_t); +int pthread_self(); + +int pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t *attr); +int pthread_mutex_destroy(pthread_mutex_t *mutex); +int pthread_mutex_lock(pthread_mutex_t *mutex); +int pthread_mutex_unlock(pthread_mutex_t *mutex); + +int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *attr); +int pthread_cond_destroy(pthread_cond_t *cond); +int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); +int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime); +int pthread_cond_signal(pthread_cond_t *cond); +int pthread_cond_broadcast(pthread_cond_t *cond); + +int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr); +int pthread_rwlock_destroy(pthread_rwlock_t *rwlock); +int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); +int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock); +int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock); +int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock); +int pthread_rwlock_unlock(pthread_rwlock_t *rwlock); +#endif + +// Helper functions +unsigned int pcthread_get_num_procs(); + +void ms_to_timespec(struct timespec *ts, uint32 ms); diff --git a/seika/thread/thread_pool.c b/seika/thread/thread_pool.c new file mode 100644 index 0000000..dc975e3 --- /dev/null +++ b/seika/thread/thread_pool.c @@ -0,0 +1,184 @@ +#include "thread_pool.h" + +#include "seika/memory.h" + +// --- Thread Pool Worker --- // +static SkaThreadPoolWork* tpool_work_create(SkaThreadFunc func, void *arg) { + SkaThreadPoolWork* work; + + if (func == NULL) { + return NULL; + } + + work = SKA_MEM_ALLOCATE_SIZE(sizeof(*work)); + work->func = func; + work->arg = arg; + work->next = NULL; + return work; +} + +static void tpool_work_destroy(SkaThreadPoolWork* work) { + if (work == NULL) { + return; + } + SKA_MEM_FREE(work); +} + + +static SkaThreadPoolWork* tpool_work_get(SkaThreadPool* tp) { + SkaThreadPoolWork* work; + + if (tp == NULL) { + return NULL; + } + + work = tp->workFirst; + if (work == NULL) { + return NULL; + } + + if (work->next == NULL) { + tp->workFirst = NULL; + tp->workLast = NULL; + } else { + tp->workFirst = work->next; + } + + return work; +} + +static void* tpool_worker(void *arg) { + SkaThreadPool* tp = arg; + SkaThreadPoolWork* work; + + while (true) { + pthread_mutex_lock(&(tp->workMutex)); + + while (tp->workFirst == NULL && !tp->shouldStop) { + pthread_cond_wait(&(tp->workCond), &(tp->workMutex)); + } + + if (tp->shouldStop) { + break; + } + + work = tpool_work_get(tp); + tp->workingCount++; + pthread_mutex_unlock(&(tp->workMutex)); + + if (work != NULL) { + work->func(work->arg); + tpool_work_destroy(work); + } + + pthread_mutex_lock(&(tp->workMutex)); + tp->workingCount--; + if (!tp->shouldStop && tp->workingCount == 0 && tp->workFirst == NULL) { + pthread_cond_signal(&(tp->workingCond)); + } + pthread_mutex_unlock(&(tp->workMutex)); + } + + tp->threadCount--; + pthread_cond_signal(&(tp->workingCond)); + pthread_mutex_unlock(&(tp->workMutex)); + return NULL; +} + + +// --- Thread Pool --- // +SkaThreadPool* ska_tpool_create(usize num) { + SkaThreadPool* tp; + pthread_t thread; + + if (num == 0) { + num = 2; + } + + tp = SKA_MEM_ALLOCATE_SIZE_ZERO(1, sizeof(*tp)); + tp->threadCount = num; + + pthread_mutex_init(&(tp->workMutex), NULL); + pthread_cond_init(&(tp->workCond), NULL); + pthread_cond_init(&(tp->workingCond), NULL); + + tp->workFirst = NULL; + tp->workLast = NULL; + + for (usize i = 0; i < num; i++) { + pthread_create(&thread, NULL, tpool_worker, tp); + pthread_detach(thread); + } + + return tp; +} + +void ska_tpool_destroy(SkaThreadPool* tp) { + SkaThreadPoolWork* work; + SkaThreadPoolWork* work2; + + if (tp == NULL) + return; + + pthread_mutex_lock(&(tp->workMutex)); + work = tp->workFirst; + while (work != NULL) { + work2 = work->next; + tpool_work_destroy(work); + work = work2; + } + tp->shouldStop = true; + pthread_cond_broadcast(&(tp->workCond)); + pthread_mutex_unlock(&(tp->workMutex)); + + ska_tpool_wait(tp); + + pthread_mutex_destroy(&(tp->workMutex)); + pthread_cond_destroy(&(tp->workCond)); + pthread_cond_destroy(&(tp->workingCond)); + + SKA_MEM_FREE(tp); +} + +bool ska_tpool_add_work(SkaThreadPool* tp, SkaThreadFunc func, void* arg) { + SkaThreadPoolWork* work; + + if (tp == NULL) { + return false; + } + + work = tpool_work_create(func, arg); + if (work == NULL) { + return false; + } + + pthread_mutex_lock(&(tp->workMutex)); + if (tp->workFirst == NULL) { + tp->workFirst = work; + tp->workLast = tp->workFirst; + } else { + tp->workLast->next = work; + tp->workLast = work; + } + + pthread_cond_broadcast(&(tp->workCond)); + pthread_mutex_unlock(&(tp->workMutex)); + + return true; +} + +void ska_tpool_wait(SkaThreadPool* tp) { + if (tp == NULL) { + return; + } + + pthread_mutex_lock(&(tp->workMutex)); + while (true) { + if ((!tp->shouldStop && tp->workingCount != 0) || (tp->shouldStop && tp->threadCount != 0)) { + pthread_cond_wait(&(tp->workingCond), &(tp->workMutex)); + } else { + break; + } + } + pthread_mutex_unlock(&(tp->workMutex)); +} diff --git a/seika/thread/thread_pool.h b/seika/thread/thread_pool.h new file mode 100644 index 0000000..438bd14 --- /dev/null +++ b/seika/thread/thread_pool.h @@ -0,0 +1,32 @@ +#pragma once + +#include +#include + +#include "seika/thread/pthread.h" + +typedef void (*SkaThreadFunc)(void* arg); + +typedef struct SkaThreadPoolWork { + SkaThreadFunc func; + void* arg; + struct SkaThreadPoolWork* next; +} SkaThreadPoolWork; + +typedef struct SkaThreadPool { + SkaThreadPoolWork* workFirst; + SkaThreadPoolWork* workLast; + pthread_mutex_t workMutex; + pthread_cond_t workCond; + pthread_cond_t workingCond; + usize workingCount; + usize threadCount; + bool shouldStop; +} SkaThreadPool; + +SkaThreadPool* ska_tpool_create(usize num); +void ska_tpool_destroy(SkaThreadPool* tp); +// Adds worker (or job) to the thread pool. +bool ska_tpool_add_work(SkaThreadPool* tp, SkaThreadFunc func, void* arg); +// Blocking function that finishes once all work is completed. +void ska_tpool_wait(SkaThreadPool* tp); From f720747aa3c691bfb8773c0bc99cf1b3b36563fb Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 17 Oct 2024 23:38:24 -0400 Subject: [PATCH 24/55] More. --- seika/asset/asset_file_loader.c | 134 ++++ seika/asset/asset_file_loader.h | 46 ++ seika/asset/asset_manager.c | 111 ++++ seika/asset/asset_manager.h | 32 + seika/audio/audio.c | 74 +++ seika/audio/audio.h | 33 + seika/audio/audio_manager.c | 201 ++++++ seika/audio/audio_manager.h | 22 + seika/file_system.c | 190 ++++++ seika/file_system.h | 26 + seika/rendering/font.c | 136 ++++ seika/rendering/font.h | 30 + seika/rendering/frame_buffer.c | 185 ++++++ seika/rendering/frame_buffer.h | 38 ++ seika/rendering/render_context.c | 27 + seika/rendering/render_context.h | 20 + seika/rendering/renderer.c | 614 ++++++++++++++++++ seika/rendering/renderer.h | 39 ++ seika/rendering/shader/shader.c | 93 +++ seika/rendering/shader/shader.h | 30 + seika/rendering/shader/shader_cache.c | 121 ++++ seika/rendering/shader/shader_cache.h | 23 + seika/rendering/shader/shader_file_parser.c | 611 +++++++++++++++++ seika/rendering/shader/shader_file_parser.h | 32 + seika/rendering/shader/shader_instance.c | 201 ++++++ seika/rendering/shader/shader_instance.h | 76 +++ .../shader/shader_instance_minimal.h | 12 + seika/rendering/shader/shader_source.h | 133 ++++ seika/rendering/texture.c | 156 +++++ seika/rendering/texture.h | 46 ++ 30 files changed, 3492 insertions(+) create mode 100644 seika/asset/asset_file_loader.c create mode 100644 seika/asset/asset_file_loader.h create mode 100644 seika/asset/asset_manager.c create mode 100644 seika/asset/asset_manager.h create mode 100644 seika/audio/audio.c create mode 100644 seika/audio/audio.h create mode 100644 seika/audio/audio_manager.c create mode 100644 seika/audio/audio_manager.h create mode 100644 seika/file_system.c create mode 100644 seika/file_system.h create mode 100644 seika/rendering/font.c create mode 100644 seika/rendering/font.h create mode 100644 seika/rendering/frame_buffer.c create mode 100644 seika/rendering/frame_buffer.h create mode 100644 seika/rendering/render_context.c create mode 100644 seika/rendering/render_context.h create mode 100644 seika/rendering/renderer.c create mode 100644 seika/rendering/renderer.h create mode 100644 seika/rendering/shader/shader.c create mode 100644 seika/rendering/shader/shader.h create mode 100644 seika/rendering/shader/shader_cache.c create mode 100644 seika/rendering/shader/shader_cache.h create mode 100644 seika/rendering/shader/shader_file_parser.c create mode 100644 seika/rendering/shader/shader_file_parser.h create mode 100644 seika/rendering/shader/shader_instance.c create mode 100644 seika/rendering/shader/shader_instance.h create mode 100644 seika/rendering/shader/shader_instance_minimal.h create mode 100644 seika/rendering/shader/shader_source.h create mode 100644 seika/rendering/texture.c create mode 100644 seika/rendering/texture.h diff --git a/seika/asset/asset_file_loader.c b/seika/asset/asset_file_loader.c new file mode 100644 index 0000000..6c78934 --- /dev/null +++ b/seika/asset/asset_file_loader.c @@ -0,0 +1,134 @@ +#include "asset_file_loader.h" + +#if SKA_RENDERING +#include + +#include "seika/memory.h" +#endif + +#include + +#include "seika/string.h" +#include "seika/file_system.h" + +SkaAssetFileLoaderReadMode globalReadMode = SkaAssetFileLoaderReadMode_DISK; +struct zip_t* packageArchive = NULL; + +static void clear_package_archive() { + if (packageArchive != NULL) { + zip_entry_close(packageArchive); + packageArchive = NULL; + } +} + +void ska_asset_file_loader_initialize() {} + +void ska_asset_file_loader_finalize() { + clear_package_archive(); +} + +bool ska_asset_file_loader_load_archive(const char* filePath) { + if (ska_fs_does_file_exist(filePath)) { + clear_package_archive(); + packageArchive = zip_open(filePath, 0, 'r'); + return true; + } + return false; +} + +void ska_asset_file_loader_set_read_mode(SkaAssetFileLoaderReadMode readMode) { + globalReadMode = readMode; +} + +SkaAssetFileLoaderReadMode ska_asset_file_loader_get_read_mode() { + return globalReadMode; +} + +SkaArchiveFileAsset ska_asset_file_loader_get_asset(const char* path) { + void* fileBuffer = NULL; + usize fileBufferSize; + zip_entry_open(packageArchive, path); + { + zip_entry_read(packageArchive, &fileBuffer, &fileBufferSize); + } + return (SkaArchiveFileAsset) { + .buffer = fileBuffer, + .bufferSize = fileBufferSize + }; +} + +SkaArchiveFileAsset ska_asset_file_loader_load_asset_from_disk(const char* path) { + SkaArchiveFileAsset asset = {NULL, 0 }; + if (ska_fs_does_file_exist(path)) { + asset.buffer = ska_fs_read_file_contents(path, &asset.bufferSize); + } + return asset; +} + +bool ska_asset_file_loader_is_asset_valid(SkaArchiveFileAsset* fileAsset) { + return fileAsset != NULL && fileAsset->buffer != NULL; +} + +char* ska_asset_file_loader_read_file_contents_as_string(const char* filePath, usize* size) { + char* fileString = NULL; + usize len = 0; + if (globalReadMode == SkaAssetFileLoaderReadMode_DISK) { + if (ska_fs_does_file_exist(filePath)) { + fileString = ska_fs_read_file_contents(filePath, &len); + } + } else if (globalReadMode == SkaAssetFileLoaderReadMode_ARCHIVE) { + SkaArchiveFileAsset fileAsset = ska_asset_file_loader_get_asset(filePath); + if (ska_asset_file_loader_is_asset_valid(&fileAsset)) { + fileString = ska_strdup_from_memory(fileAsset.buffer, fileAsset.bufferSize); + len = fileAsset.bufferSize; + } + } + if (size) { + *size = len; + } + return fileString; +} + +char* ska_asset_file_loader_read_file_contents_as_string_without_raw(const char* filePath, usize* size) { + char* fileString = NULL; + usize len = 0; + if (globalReadMode == SkaAssetFileLoaderReadMode_DISK) { + if (ska_fs_does_file_exist(filePath)) { + fileString = ska_fs_read_file_contents_without_raw(filePath, &len); + } + } else if (globalReadMode == SkaAssetFileLoaderReadMode_ARCHIVE) { + SkaArchiveFileAsset fileAsset = ska_asset_file_loader_get_asset(filePath); + if (ska_asset_file_loader_is_asset_valid(&fileAsset)) { + fileString = ska_strdup_from_memory(fileAsset.buffer, fileAsset.bufferSize); + ska_str_remove_char(fileString, '\r'); + len = fileAsset.bufferSize; + } + } + if (size) { + *size = len; + } + return fileString; +} + +#if SKA_RENDERING +SkaAssetFileImageData* ska_asset_file_loader_load_image_data(const char* filePath) { + SkaAssetFileImageData* imageData = NULL; + stbi_set_flip_vertically_on_load(false); + if (globalReadMode == SkaAssetFileLoaderReadMode_DISK) { + imageData = SKA_ALLOC(SkaAssetFileImageData); + imageData->data = stbi_load(filePath, &imageData->width, &imageData->height, &imageData->nrChannels, 0); + } else if (globalReadMode == SkaAssetFileLoaderReadMode_ARCHIVE) { + SkaArchiveFileAsset fileAsset = ska_asset_file_loader_get_asset(filePath); + if (ska_asset_file_loader_is_asset_valid(&fileAsset)) { + imageData = SKA_ALLOC(SkaAssetFileImageData); + imageData->data = stbi_load_from_memory(fileAsset.buffer, (int32)fileAsset.bufferSize, &imageData->width, &imageData->height, &imageData->nrChannels, 0); + } + } + return imageData; +} + +void ska_asset_file_loader_free_image_data(SkaAssetFileImageData* data) { + stbi_image_free(data->data); + SKA_MEM_FREE(data); +} +#endif // #if SKA_RENDERING diff --git a/seika/asset/asset_file_loader.h b/seika/asset/asset_file_loader.h new file mode 100644 index 0000000..efeef93 --- /dev/null +++ b/seika/asset/asset_file_loader.h @@ -0,0 +1,46 @@ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "seika/defines.h" + +typedef enum SkaAssetFileLoaderReadMode { + SkaAssetFileLoaderReadMode_DISK, + SkaAssetFileLoaderReadMode_ARCHIVE, +} SkaAssetFileLoaderReadMode; + +typedef struct SkaArchiveFileAsset { + void* buffer; + usize bufferSize; +} SkaArchiveFileAsset; + +typedef struct SkaAssetFileImageData { + unsigned char* data; + int32 width; + int32 height; + int32 nrChannels; +} SkaAssetFileImageData; + +void ska_asset_file_loader_initialize(); +void ska_asset_file_loader_finalize(); +bool ska_asset_file_loader_load_archive(const char* filePath); +void ska_asset_file_loader_set_read_mode(SkaAssetFileLoaderReadMode readMode); +SkaAssetFileLoaderReadMode ska_asset_file_loader_get_read_mode(); +SkaArchiveFileAsset ska_asset_file_loader_get_asset(const char* path); +SkaArchiveFileAsset ska_asset_file_loader_load_asset_from_disk(const char* path); +bool ska_asset_file_loader_is_asset_valid(SkaArchiveFileAsset* fileAsset); + +// Asset loading types +char* ska_asset_file_loader_read_file_contents_as_string(const char* filePath, usize* size); +char* ska_asset_file_loader_read_file_contents_as_string_without_raw(const char* filePath, usize* size); + +#if SKA_RENDERING +SkaAssetFileImageData* ska_asset_file_loader_load_image_data(const char* filePath); +void ska_asset_file_loader_free_image_data(SkaAssetFileImageData* data); +#endif // #if SKA_RENDERING + +#ifdef __cplusplus +} +#endif diff --git a/seika/asset/asset_manager.c b/seika/asset/asset_manager.c new file mode 100644 index 0000000..8048731 --- /dev/null +++ b/seika/asset/asset_manager.c @@ -0,0 +1,111 @@ +#include "asset_manager.h" + +#include "seika/memory.h" +#include "seika/assert.h" +#include "seika/data_structures/hash_map_string.h" +#include "seika/rendering/texture.h" +#include "seika/rendering/font.h" +#include "seika/audio/audio.h" + +static SkaStringHashMap* texturesMap = NULL; +static SkaStringHashMap* fontMap = NULL; +static SkaStringHashMap* audioSourceMap = NULL; + +void ska_asset_manager_initialize() { + texturesMap = ska_string_hash_map_create_default_capacity(); + fontMap = ska_string_hash_map_create_default_capacity(); + audioSourceMap = ska_string_hash_map_create_default_capacity(); +} + +void ska_asset_manager_finalize() { + ska_string_hash_map_destroy(texturesMap); + ska_string_hash_map_destroy(fontMap); + ska_string_hash_map_destroy(audioSourceMap); +} + +#if SKA_RENDERING +// --- Texture --- // +SkaTexture* ska_asset_manager_load_texture(const char* fileName, const char* key) { + SKA_ASSERT(texturesMap != NULL); + SKA_ASSERT_FMT(!ska_string_hash_map_has(texturesMap, fileName), "Already loaded texture at file path '%'s! Has key '%s'.", fileName, key); + SkaTexture* texture = ska_texture_create_texture(fileName); + ska_string_hash_map_add(texturesMap, key, texture, sizeof(SkaTexture)); + SKA_MEM_FREE(texture); + texture = (SkaTexture*) ska_string_hash_map_get(texturesMap, key); + return texture; +} + +SkaTexture* ska_asset_manager_load_texture_ex(const char* fileName, const char* key, const char* wrap_s, const char* wrap_t, bool applyNearestNeighbor) { + SKA_ASSERT(texturesMap != NULL); + SKA_ASSERT_FMT(!ska_string_hash_map_has(texturesMap, fileName), "Already loaded texture at file path '%'s! Has key '%s'.", fileName, key); + SkaTexture* texture = ska_texture_create_texture2( + fileName, + ska_texture_wrap_string_to_int(wrap_s), + ska_texture_wrap_string_to_int(wrap_t), + applyNearestNeighbor + ); + ska_string_hash_map_add(texturesMap, key, texture, sizeof(SkaTexture)); + SKA_MEM_FREE(texture); + texture = (SkaTexture*) ska_string_hash_map_get(texturesMap, key); + return texture; +} + +SkaTexture* ska_asset_manager_get_texture(const char* key) { + return (SkaTexture*) ska_string_hash_map_get(texturesMap, key); +} + +bool ska_asset_manager_has_texture(const char* key) { + return ska_string_hash_map_has(texturesMap, key); +} + +// --- Font --- // +SkaFont* ska_asset_manager_load_font(const char* fileName, const char* key, int size, bool applyNearestNeighbor) { + SKA_ASSERT_FMT(!ska_asset_manager_has_font(key), "Font key '%s' already exists!", key); + SkaFont* font = ska_font_create_font(fileName, size, applyNearestNeighbor); + SKA_ASSERT_FMT(font != NULL, "Failed to load font! file_name: '%s', key: '%s', size: '%d'", fileName, key, size); + ska_string_hash_map_add(fontMap, key, font, sizeof(SkaFont)); + SKA_MEM_FREE(font); + font = (SkaFont*) ska_string_hash_map_get(fontMap, key); + return font; +} + +SkaFont* ska_asset_manager_load_font_from_memory(const char* key, void* buffer, usize bufferSize, int size, bool applyNearestNeighbor) { + SKA_ASSERT_FMT(!ska_asset_manager_has_font(key), "Font key '%s' already exists!", key); + SkaFont* font = ska_font_create_font_from_memory(buffer, bufferSize, size, applyNearestNeighbor); + SKA_ASSERT_FMT(font != NULL, "Failed to load font! key: '%s', size: '%d'", key, size); + ska_string_hash_map_add(fontMap, key, font, sizeof(SkaFont)); + SKA_MEM_FREE(font); + font = (SkaFont*) ska_string_hash_map_get(fontMap, key); + return font; +} + + +SkaFont* ska_asset_manager_get_font(const char* key) { + return (SkaFont*) ska_string_hash_map_get(fontMap, key); +} + +bool ska_asset_manager_has_font(const char* key) { + return ska_string_hash_map_has(fontMap, key); +} +#endif // #if SKA_RENDERING + +#if SKA_AUDIO +// --- Audio Source --- // +SkaAudioSource* ska_asset_manager_load_audio_source_wav(const char* fileName, const char* key) { + SKA_ASSERT(audioSourceMap != NULL); + SKA_ASSERT_FMT(!ska_string_hash_map_has(audioSourceMap, fileName), "Already loaded audio source at file path '%'s! Has key '%s'.", fileName, key); + SkaAudioSource* newAudioSource = ska_audio_load_audio_source_wav(fileName); + SKA_ASSERT_FMT(newAudioSource != NULL, "Audio source is null! file_name = '%s', key = '%s'", fileName, key); + ska_string_hash_map_add(audioSourceMap, key, newAudioSource, sizeof(SkaAudioSource)); + SKA_MEM_FREE(newAudioSource); + return newAudioSource; +} + +SkaAudioSource* ska_asset_manager_get_audio_source(const char* key) { + return (SkaAudioSource*) ska_string_hash_map_get(audioSourceMap, key); +} + +bool ska_asset_manager_has_audio_source(const char* key) { + return ska_string_hash_map_has(audioSourceMap, key); +} +#endif // #if SKA_AUDIO diff --git a/seika/asset/asset_manager.h b/seika/asset/asset_manager.h new file mode 100644 index 0000000..a10d0d5 --- /dev/null +++ b/seika/asset/asset_manager.h @@ -0,0 +1,32 @@ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "seika/defines.h" + +void ska_asset_manager_initialize(); +void ska_asset_manager_finalize(); + +#if SKA_RENDERING +struct SkaTexture* ska_asset_manager_load_texture(const char* fileName, const char* key); +struct SkaTexture* ska_asset_manager_load_texture_ex(const char* fileName, const char* key, const char* wrap_s, const char* wrap_t, bool applyNearestNeighbor); +struct SkaTexture* ska_asset_manager_get_texture(const char* key); +bool ska_asset_manager_has_texture(const char* key); + +struct SkaFont* ska_asset_manager_load_font(const char* fileName, const char* key, int size, bool applyNearestNeighbor); +struct SkaFont* ska_asset_manager_load_font_from_memory(const char* key, void* buffer, usize bufferSize, int size, bool applyNearestNeighbor); +struct SkaFont* ska_asset_manager_get_font(const char* key); +bool ska_asset_manager_has_font(const char* key); +#endif // #if SKA_RENDERING + +#if SKA_AUDIO +struct SkaAudioSource* ska_asset_manager_load_audio_source_wav(const char* fileName, const char* key); +struct SkaAudioSource* ska_asset_manager_get_audio_source(const char* key); +bool ska_asset_manager_has_audio_source(const char* key); +#endif // #if SKA_AUDIO + +#ifdef __cplusplus +} +#endif diff --git a/seika/audio/audio.c b/seika/audio/audio.c new file mode 100644 index 0000000..823944e --- /dev/null +++ b/seika/audio/audio.c @@ -0,0 +1,74 @@ +#if SKA_AUDIO + +#include "audio.h" + +#define MINIAUDIO_IMPLEMENTATION +#include + +#include "seika/memory.h" +#include "seika/logger.h" +#include "seika/asset/asset_file_loader.h" + +static uint32 audioWavSampleRate = SKA_AUDIO_SOURCE_DEFAULT_WAV_SAMPLE_RATE; + +static bool load_wav_data_from_file(const char* file_path, int32* sample_count, int32* channels, int32* sample_rate, void** samples); + +void ska_audio_print_audio_source(SkaAudioSource* audioSource) { + ska_logger_debug("audio source | channels = %d, sample rate = %d, sample count = %d, samples = %x", + audioSource->channels, audioSource->sample_rate, audioSource->sample_count, audioSource->samples); +} + +void ska_audio_set_wav_sample_rate(uint32 wavSampleRate) { + audioWavSampleRate = wavSampleRate; +} + +uint32_t ska_audio_get_wav_sample_rate() { + return audioWavSampleRate; +} + +SkaAudioSource* ska_audio_load_audio_source_wav(const char* fileName) { + int32_t sampleCount; + int32_t channels; + int32_t sampleRate; + void* samples = NULL; + if (!load_wav_data_from_file(fileName, &sampleCount, &channels, &sampleRate, &samples)) { + ska_logger_error("Failed to load audio wav file at '%s'", fileName); + return NULL; + } + SkaAudioSource* newAudioSource = (SkaAudioSource*)SKA_MEM_ALLOCATE_SIZE(sizeof(SkaAudioSource*) + (sampleCount * sizeof(int16_t*))); + newAudioSource->file_path = fileName; + newAudioSource->pitch = 1.0; + newAudioSource->sample_count = sampleCount; + newAudioSource->channels = channels; + newAudioSource->sample_rate = sampleRate; + newAudioSource->samples = samples; + + if ((uint32_t)newAudioSource->sample_rate != audioWavSampleRate) { + ska_logger_error("Sample rate for wav file '%s' is %d instead of the expected sample rate of %d! Audio won't play as expected!", + fileName, sampleRate, audioWavSampleRate); + } + + return newAudioSource; +} + +bool load_wav_data_from_file(const char* file_path, int32_t* sample_count, int32_t* channels, int32_t* sample_rate, void** samples) { + usize len = 0; + char* file_data = ska_asset_file_loader_read_file_contents_as_string(file_path, &len); + ska_logger_debug("file '%s' size '%u' bytes", file_path, len); + + drwav_uint64 totalPcmFrameCount = 0; + *samples = drwav_open_memory_and_read_pcm_frames_s16(file_data, len, (uint32_t*)channels, (uint32_t*)sample_rate, &totalPcmFrameCount, NULL); + SKA_MEM_FREE(file_data); + + if (!*samples) { + *samples = NULL; + ska_logger_error("Could not load .wav file: %s", file_path); + return false; + } + + *sample_count = (int32_t) totalPcmFrameCount * *channels; + + return true; +} + +#endif // #if SKA_AUDIO diff --git a/seika/audio/audio.h b/seika/audio/audio.h new file mode 100644 index 0000000..2d50bb4 --- /dev/null +++ b/seika/audio/audio.h @@ -0,0 +1,33 @@ +#pragma once + +#if SKA_AUDIO + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#include "seika/defines.h" + +#define SKA_AUDIO_SOURCE_DEFAULT_WAV_SAMPLE_RATE 44100 + +typedef struct SkaAudioSource { + const char* file_path; + f64 pitch; + int32 channels; + int32 sample_rate; + void* samples; + int32 sample_count; +} SkaAudioSource; + +void ska_audio_print_audio_source(SkaAudioSource* audioSource); +void ska_audio_set_wav_sample_rate(uint32 wavSampleRate); +uint32 ska_audio_get_wav_sample_rate(); +SkaAudioSource* ska_audio_load_audio_source_wav(const char* fileName); + +#ifdef __cplusplus +} +#endif + +#endif // #if SKA_AUDIO diff --git a/seika/audio/audio_manager.c b/seika/audio/audio_manager.c new file mode 100644 index 0000000..1b6bec5 --- /dev/null +++ b/seika/audio/audio_manager.c @@ -0,0 +1,201 @@ +#if SKA_AUDIO + +#include "audio_manager.h" + +#include +#include + +#include + +#include "audio.h" +#include "seika/memory.h" +#include "seika/logger.h" +#include "seika/assert.h" +#include "seika/asset/asset_manager.h" +#include "seika/thread/pthread.h" + +#define SKA_MAX_AUDIO_INSTANCES 32 + +static void audio_data_callback(ma_device* device, void* output, const void* input, ma_uint32 frame_count); + +static ma_device* audio_device = NULL; +static pthread_mutex_t audio_mutex; + +// An instance of an RBE audio source +typedef struct SkaAudioInstance { + SkaAudioSource* source; + uint32 id; + bool is_playing; + bool does_loop; + f64 sample_position; +} SkaAudioInstance; + +typedef struct SkaAudioInstances { + SkaAudioInstance* instances[SKA_MAX_AUDIO_INSTANCES]; + usize count; +} SkaAudioInstances; + +static SkaAudioInstances* audio_instances = NULL; + +// --- Audio Manager --- // +bool ska_audio_manager_init(uint32 wavSampleRate) { + audio_instances = SKA_MEM_ALLOCATE(SkaAudioInstances); + pthread_mutex_init(&audio_mutex, NULL); + ska_audio_set_wav_sample_rate(wavSampleRate); + // Device + ma_device_config config = ma_device_config_init(ma_device_type_playback); + config.playback.pDeviceID = NULL; + config.playback.format = ma_format_s16; + config.playback.channels = 2; + config.capture.pDeviceID = NULL; + config.capture.format = ma_format_s16; + config.capture.channels = 1; + config.sampleRate = wavSampleRate; + config.dataCallback = audio_data_callback; + config.pUserData = NULL; + audio_device = SKA_MEM_ALLOCATE(ma_device); + if (ma_device_init(NULL, &config, audio_device) != MA_SUCCESS) { + ska_logger_error("Failed to initialize miniaudio device!"); + return false; + } + + if (ma_device_start(audio_device) != MA_SUCCESS) { + ska_logger_error("Failed to start audio device!"); + return false; + } + + return true; +} + +void ska_audio_manager_finalize() { + ma_device_uninit(audio_device); + SKA_MEM_FREE(audio_device); + audio_device = NULL; + + SKA_MEM_FREE(audio_instances); // TODO: Properly free up all instances + audio_instances = NULL; + + pthread_mutex_destroy(&audio_mutex); +} + +void ska_audio_manager_play_sound(const char* filePath, bool loops) { + if (!ska_asset_manager_has_audio_source(filePath)) { + ska_logger_error("Doesn't have audio source loaded at path '%s' loaded! Aborting...", filePath); + return; + } else if (audio_instances->count >= SKA_MAX_AUDIO_INSTANCES) { + ska_logger_warn("Reached max audio instances of '%d', not playing sound!", SKA_MAX_AUDIO_INSTANCES); + return; + } + + pthread_mutex_lock(&audio_mutex); + // Create audio instance and add to instances array + static unsigned int audioInstanceId = 0; // TODO: temp id for now in case we need to grab a hold of an audio instance for roll back later... + SkaAudioInstance* audioInstance = SKA_MEM_ALLOCATE(SkaAudioInstance); + audioInstance->source = ska_asset_manager_get_audio_source(filePath); + audioInstance->id = audioInstanceId++; + audioInstance->does_loop = loops; + audioInstance->sample_position = 0.0f; + audioInstance->is_playing = true; // Sets sound instance to be played + + audio_instances->instances[audio_instances->count++] = audioInstance; + ska_logger_debug("Added audio instance from file path '%s' to play!", filePath); + pthread_mutex_unlock(&audio_mutex); +} + +void ska_audio_manager_stop_sound(const char* filePath) { + pthread_mutex_lock(&audio_mutex); + for (usize i = 0; i < audio_instances->count; i++) { + SkaAudioInstance* audioInst = audio_instances->instances[i]; + if (strcmp(audioInst->source->file_path, filePath) == 0) { + audioInst->is_playing = false; + break; + } + } + pthread_mutex_unlock(&audio_mutex); +} + +// --- Mini Audio Callback --- // +void audio_data_callback(ma_device* device, void* output, const void* input, ma_uint32 frame_count) { + if (audio_instances->count <= 0) { + return; + } + + pthread_mutex_lock(&audio_mutex); + memset(output, 0, frame_count * device->playback.channels * ma_get_bytes_per_sample(device->playback.format)); + usize removedInstances = 0; + for (usize i = 0; i < audio_instances->count; i++) { + SkaAudioInstance* audioInst = audio_instances->instances[i]; + SKA_ASSERT_FMT(audioInst != NULL, "audio instance with index %zu is null!", i); + if (!audioInst->is_playing) { + SKA_MEM_FREE(audioInst); + audio_instances->instances[i] = NULL; + removedInstances++; + continue; + } + + const int32_t channels = audioInst->source->channels; + const f64 pitch = audioInst->source->pitch; + int16* sampleOut = (int16*) output; + int16* samples = (int16*) audioInst->source->samples; + uint64_t samplesToWrite = (uint64_t) frame_count; + + // Write to output + for (uint64_t writeSample = 0; writeSample < samplesToWrite; writeSample++) { + f64 startSamplePosition = audioInst->sample_position; + + f64 targetSamplePosition = startSamplePosition + (f64)channels * pitch; + if (targetSamplePosition >= audioInst->source->sample_count) { + targetSamplePosition -= (f64)audioInst->source->sample_count; + } + + uint64 leftId = (uint64) startSamplePosition; + if (channels > 1) { + leftId &= ~((uint64)(0x01)); + } + const uint64 rightId = leftId + (uint64)(channels - 1); + const int16 startLeftSample = samples[leftId + channels]; + const int16 startRightSample = samples[rightId + channels]; + + const int16 leftSample = (int16)(startLeftSample / channels); + const int16 rightSample = (int16)(startRightSample / channels); + + *sampleOut++ += leftSample; // Left + *sampleOut++ += rightSample; // Right + + // Possibly need fixed sampling instead + audioInst->sample_position = targetSamplePosition; + + const bool isAtEnd = audioInst->sample_position >= audioInst->source->sample_count - channels - 1; + if (isAtEnd) { + audioInst->sample_position = 0; + if (!audioInst->does_loop) { + ska_logger_debug("Audio instance with id '%u' is queued for deletion!", audioInst->id); + audio_instances->instances[i] = NULL; + removedInstances++; + SKA_MEM_FREE(audioInst); + break; + } + } + } + } + + // Reshuffle array and update count if data sources have been removed + if (removedInstances > 0) { + static SkaAudioInstance* tempAudioInstances[SKA_MAX_AUDIO_INSTANCES]; + usize newCount = 0; + // Place non-null instances in temp array + for (usize i = 0; i < audio_instances->count; i++) { + if (audio_instances->instances[i] != NULL) { + tempAudioInstances[newCount++] = audio_instances->instances[i]; + } + } + // Now fill up regular array + for (usize i = 0; i < newCount; i++) { + audio_instances->instances[i] = tempAudioInstances[i]; + } + audio_instances->count = newCount; + } + pthread_mutex_unlock(&audio_mutex); +} + +#endif // #if SKA_AUDIO diff --git a/seika/audio/audio_manager.h b/seika/audio/audio_manager.h new file mode 100644 index 0000000..9ffec71 --- /dev/null +++ b/seika/audio/audio_manager.h @@ -0,0 +1,22 @@ +#pragma once + +#if SKA_AUDIO + +#ifdef __cplusplus +extern "C" { +#endif + +#include "seika/defines.h" + +// --- Audio Manager --- // +bool ska_audio_manager_init(uint32 wavSampleRate); +void ska_audio_manager_finalize(); +// Process current jobs for resource manager +void ska_audio_manager_play_sound(const char* filePath, bool loops); +void ska_audio_manager_stop_sound(const char* filePath); + +#ifdef __cplusplus +} +#endif + +#endif // #if SKA_AUDIO diff --git a/seika/file_system.c b/seika/file_system.c new file mode 100644 index 0000000..2b11391 --- /dev/null +++ b/seika/file_system.c @@ -0,0 +1,190 @@ +#include "file_system.h" + +#ifdef _WIN32 +#include +#include +#else +#include +#endif + +#include +#include + +#if defined(_MSC_VER) +#include +#include +#else +#include +#include + +#endif + + +#include + +#include "logger.h" +#include "seika/string.h" +#include "seika/memory.h" + +#ifdef _MSC_VER +#pragma warning(disable : 4996) // for fopen +#endif + +#define CHAR_ARRAY_MAX_BUFFER_SIZE 256 + +void ska_fs_get_cwd_array(char* array, usize size) { + if (getcwd(array, (int) size) != NULL) { + return; + } +} + +bool ska_fs_chdir(const char* dirPath) { + char currentWorkingPath[CHAR_ARRAY_MAX_BUFFER_SIZE]; + ska_fs_get_cwd_array(currentWorkingPath, CHAR_ARRAY_MAX_BUFFER_SIZE); + if (strcmp(currentWorkingPath, dirPath) == 0) { + ska_logger_warn("Attempting to change to the same directory at path '%s'", currentWorkingPath); + return false; + } + if (chdir(dirPath) == 0) { + return true; + } + ska_logger_error("Failed to change directory to path '%s'", dirPath); + return false; +} + +char* ska_fs_get_cwd() { + char cwd[CHAR_ARRAY_MAX_BUFFER_SIZE]; + if (getcwd(cwd, sizeof(cwd)) != NULL) { + return ska_strdup(cwd); + } + return NULL; +} + +void ska_fs_print_cwd() { + char cwd[CHAR_ARRAY_MAX_BUFFER_SIZE]; + if (getcwd(cwd, sizeof(cwd)) != NULL) { + ska_logger_info("Current working directory: %s\n", cwd); + } else { + ska_logger_error("Not able to get current working directory!"); + } +} + +usize ska_fs_get_file_size(const char* filePath) { +#ifdef _WIN32 + HANDLE hFile = CreateFile(filePath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + if (hFile == INVALID_HANDLE_VALUE) { + ska_logger_error("Error invalid handle value when getting file size at path '%s'", filePath); + return 0; + } + + LARGE_INTEGER size; + if (!GetFileSizeEx(hFile, &size)) { + CloseHandle(hFile); + ska_logger_error("Error getting file size at path '%s'", filePath); + return 0; + } + + CloseHandle(hFile); + return (usize) size.QuadPart; +#else + struct stat st; + stat(filePath, &st); + return (usize) st.st_size; +#endif +} + +bool ska_fs_write_to_file(const char* filePath, const char* contents) { + FILE* fp = fopen(filePath, "w"); + if (fp) { + fprintf(fp, "%s\n", contents); + fclose(fp); + return true; + } + return false; +} + +char* ska_fs_read_file_contents(const char* filePath, usize* sz) { + char* buffer = NULL; + FILE* fp = fopen(filePath, "rb"); + usize readSize = 0; + if (fp) { + readSize = ska_fs_get_file_size(filePath); + // Update buffer + buffer = (char*)SKA_MEM_ALLOCATE_SIZE(readSize + 1); + if (buffer != NULL) { + fread(buffer, 1, readSize, fp); + buffer[readSize] = '\0'; + } + fclose(fp); + } + if (sz != NULL) { + *sz = readSize; + } + return buffer; +} + +char* ska_fs_read_file_contents_without_raw(const char* filePath, usize* sz) { + char* buffer = NULL; + FILE* fp = fopen(filePath, "r"); + usize readSize = 0; + if (fp) { + readSize = ska_fs_get_file_size(filePath); + // Update buffer + buffer = (char*)SKA_MEM_ALLOCATE_SIZE(readSize + 1); + if (buffer != NULL) { + usize bytesRead = 0; + while (bytesRead < readSize) { + const int maxCount = (int)(readSize - bytesRead + 1); + if (fgets(buffer + bytesRead, maxCount, fp) == NULL) { + break; + } + bytesRead += strlen(buffer + bytesRead); + if (bytesRead > readSize) { + // Handle error: file contains more data than expected + break; + } + } + buffer[readSize] = '\0'; + } + fclose(fp); + } + if (sz != NULL) { + *sz = readSize; + } + return buffer; +} + +bool ska_fs_does_file_exist(const char* filePath) { + FILE* fp = fopen(filePath, "r"); + if (fp) { + fclose(fp); + return true; + } + return false; +} + +bool ska_fs_does_dir_exist(const char* dirPath) { +#if defined(WIN32) || defined(WIN64) + if (strnlen(dirPath, MAX_PATH + 1) > MAX_PATH) { + return false; + } + DWORD result = GetFileAttributesA(dirPath); + return (result != INVALID_FILE_ATTRIBUTES && (result & FILE_ATTRIBUTE_DIRECTORY)); +#else + struct stat stats; + if (stat(dirPath, &stats) == 0) { + return S_ISDIR(stats.st_mode); + } + return false; +#endif +} + +char* ska_fs_get_user_save_path(const char* orgName, const char* applicationName, const char* savePath) { + char buffer[CHAR_ARRAY_MAX_BUFFER_SIZE]; + char* filePath = SDL_GetPrefPath(orgName, applicationName); + strcpy(buffer, filePath); + strcat(buffer, savePath); + char* fullUserSavePath = ska_strdup(buffer); + SDL_free(filePath); + return fullUserSavePath; +} diff --git a/seika/file_system.h b/seika/file_system.h new file mode 100644 index 0000000..f9b6a2b --- /dev/null +++ b/seika/file_system.h @@ -0,0 +1,26 @@ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "defines.h" + +// Change directory +bool ska_fs_chdir(const char* dirPath); +// Get current working directory +char* ska_fs_get_cwd(); +// Print current working directory +void ska_fs_print_cwd(); + +usize ska_fs_get_file_size(const char* filePath); +char* ska_fs_read_file_contents(const char* filePath, usize* sz); +char* ska_fs_read_file_contents_without_raw(const char* filePath, usize* sz); +bool ska_fs_write_to_file(const char* filePath, const char* contents); +bool ska_fs_does_file_exist(const char* filePath); +bool ska_fs_does_dir_exist(const char* dirPath); +char* ska_fs_get_user_save_path(const char* orgName, const char* applicationName, const char* savePath); + +#ifdef __cplusplus +} +#endif diff --git a/seika/rendering/font.c b/seika/rendering/font.c new file mode 100644 index 0000000..3ed2a75 --- /dev/null +++ b/seika/rendering/font.c @@ -0,0 +1,136 @@ +#include "font.h" + +#if SKA_RENDERING + +#include +#include FT_FREETYPE_H + +#include "render_context.h" +#include "seika/logger.h" +#include "seika/memory.h" +#include "seika/asset/asset_file_loader.h" + +static bool ska_generate_new_font_face(const char* fileName, FT_Face* face); +static void ska_initialize_font(FT_Face face, SkaFont* font, bool applyNearestNeighbor); + +SkaFont* ska_font_create_font(const char* fileName, int32 size, bool applyNearestNeighbor) { + FT_Face face; + SkaFont* font = SKA_MEM_ALLOCATE(SkaFont); + font->size = size; + + // Failed to create font, exit out early + if (!ska_generate_new_font_face(fileName, &face)) { + ska_logger_error("Freetype failed to load font '%s' with size '%d'!", fileName, size); + font->isValid = false; + FT_Done_Face(face); + return font; + } + + ska_initialize_font(face, font, applyNearestNeighbor); + + return font; +} + +SkaFont* ska_font_create_font_from_memory(const void* buffer, usize bufferSize, int32 size, bool applyNearestNeighbor) { + FT_Face face; + SkaFont* font = SKA_MEM_ALLOCATE(SkaFont); + font->size = size; + + // Failed to create font, exit out early + if(FT_New_Memory_Face(ska_render_context_get()->freeTypeLibrary, (unsigned char*)buffer, (FT_Long)bufferSize, 0, &face)) { + ska_logger_error("Freetype failed to load font from memory!!"); + font->isValid = false; + FT_Done_Face(face); + return font; + } + + ska_initialize_font(face, font, applyNearestNeighbor); + + return font; +} + +void ska_font_delete(SkaFont* font) { + SKA_MEM_FREE(font); +} + +bool ska_generate_new_font_face(const char* fileName, FT_Face* face) { + if (ska_asset_file_loader_get_read_mode() == SkaAssetFileLoaderReadMode_ARCHIVE) { + SkaArchiveFileAsset fileAsset = ska_asset_file_loader_get_asset(fileName); + if (ska_asset_file_loader_is_asset_valid(&fileAsset)) { + if (FT_New_Memory_Face(ska_render_context_get()->freeTypeLibrary, (unsigned char*) fileAsset.buffer, (FT_Long) fileAsset.bufferSize, 0, face)) { + // Failed to create new face + return false; + } + } else { + // Failed to load asset from archive + return false; + } + } else if (ska_asset_file_loader_get_read_mode() == SkaAssetFileLoaderReadMode_DISK) { + if (FT_New_Face(ska_render_context_get()->freeTypeLibrary, fileName, 0, face)) { + // Failed to create new face + return false; + } + } + return true; +} + +static void ska_initialize_font(FT_Face face, SkaFont* font, bool applyNearestNeighbor) { + // Set size to load glyphs, width set to 0 to dynamically adjust + FT_Set_Pixel_Sizes(face, 0, font->size); + // Disable byte alignment restriction + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + // Load first 128 characters of ASCII set + for (unsigned char c = 0; c < 128; c++) { // 'c++' ;-) + // Load character glyph + if (FT_Load_Char(face, c, FT_LOAD_RENDER)) { + ska_logger_error("Freetype failed to load glyph '%u!", c); + continue; + } + // Generate texture + GLuint textTexture; + glGenTextures(1, &textTexture); + glBindTexture(GL_TEXTURE_2D, textTexture); + glTexImage2D( + GL_TEXTURE_2D, + 0, + GL_RED, + (GLsizei) face->glyph->bitmap.width, + (GLsizei) face->glyph->bitmap.rows, + 0, + GL_RED, + GL_UNSIGNED_BYTE, + face->glyph->bitmap.buffer + ); + // Texture wrap and filter options + const GLint filterType = applyNearestNeighbor ? GL_NEAREST : GL_LINEAR; + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filterType); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filterType); + // Create character struct + SkaFontCharacter character = { + .textureId = textTexture, + .size = { (f32)face->glyph->bitmap.width, (f32)face->glyph->bitmap.rows }, + .bearing = { (f32)face->glyph->bitmap_left, (f32)face->glyph->bitmap_top }, + .advance = (GLuint) face->glyph->advance.x + }; + font->characters[c] = character; + } + glBindTexture(GL_TEXTURE_2D, 0); + + // configure VAO & VBO texture quads + glGenVertexArrays(1, &font->VAO); + glGenBuffers(1, &font->VBO); + glBindVertexArray(font->VAO); + glBindBuffer(GL_ARRAY_BUFFER, font->VBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 6 * 4, NULL, GL_DYNAMIC_DRAW); + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), NULL); + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindVertexArray(0); + font->isValid = true; + + FT_Done_Face(face); +} + +#endif // #if SKA_RENDERING diff --git a/seika/rendering/font.h b/seika/rendering/font.h new file mode 100644 index 0000000..cf41c1b --- /dev/null +++ b/seika/rendering/font.h @@ -0,0 +1,30 @@ +#pragma once + +#if SKA_RENDERING + +#include + +#include + +#include "seika/math/math.h" + +typedef struct SkaFontCharacter { + GLuint textureId; + SkaVector2 size; + SkaVector2 bearing; + uint32 advance; +} SkaFontCharacter; + +typedef struct SkaFont { + bool isValid; + GLuint VAO; + GLuint VBO; + int32 size; + SkaFontCharacter characters[128]; // First 128 of ASCII set +} SkaFont; + +SkaFont* ska_font_create_font(const char* fileName, int32 size, bool applyNearestNeighbor); +SkaFont* ska_font_create_font_from_memory(const void* buffer, usize bufferSize, int32 size, bool applyNearestNeighbor); +void ska_font_delete(SkaFont* font); + +#endif // #if SKA_RENDERING \ No newline at end of file diff --git a/seika/rendering/frame_buffer.c b/seika/rendering/frame_buffer.c new file mode 100644 index 0000000..7058277 --- /dev/null +++ b/seika/rendering/frame_buffer.c @@ -0,0 +1,185 @@ +#if SKA_RENDERING + +#include "frame_buffer.h" + +#include "shader/shader.h" +#include "shader/shader_instance.h" +#include "shader/shader_source.h" +#include "seika/logger.h" +#include "seika/assert.h" + +GLuint frameBuffer = -1; +GLuint textureColorBuffer = -1; +GLuint rbo = -1; +bool hasBeenInitialized = false; + +static SkaShaderInstance defaultScreenShader; +static SkaShaderInstance* currentScreenShader = NULL; +static GLuint screenVAO = -1; +static GLuint screenVBO = -1; + +static int32 screenTextureWidth = 800; +static int32 screenTextureHeight = 600; +static int32 resolutionWidth = 800; +static int32 resolutionHeight = 600; +static SkaFrameBufferViewportData cachedViewportData = { .position = { .x = 0, .y = 0 }, .size = { .w = 800, .h = 600 } }; +static bool maintainAspectRatio = false; + +SkaFrameBufferViewportData ska_frame_buffer_generate_viewport_data(int32 windowWidth, int32 windowHeight) { + int32 framebufferWidth = windowWidth; + int32 framebufferHeight = windowHeight; + + const f32 game_aspect_ratio = (f32)resolutionWidth / (f32)resolutionHeight; + const f32 window_aspect_ratio = (f32)windowWidth / (f32)windowHeight; + + // Adjust the framebuffer width or height to match the window aspect ratio + if (maintainAspectRatio && game_aspect_ratio != window_aspect_ratio) { + framebufferHeight = (int32)((f32)windowWidth / game_aspect_ratio); + if (framebufferHeight > windowHeight) { + framebufferHeight = windowHeight; + framebufferWidth = (int32)((f32)windowHeight * game_aspect_ratio); + } + } + + // Calculate the viewport dimensions + const int32 viewportX = (windowWidth - framebufferWidth) / 2; + const int32 viewportY = (windowHeight - framebufferHeight) / 2; + const int32 viewportWidth = framebufferWidth; + const int32 viewportHeight = framebufferHeight; + + const SkaFrameBufferViewportData data = { + .position = { .x = viewportX, .y = viewportY }, + .size = { .w = viewportWidth, .h = viewportHeight } + }; + cachedViewportData = data; + return data; +} + +SkaFrameBufferViewportData* ska_frame_buffer_get_cached_viewport_data() { + return &cachedViewportData; +} + +bool recreate_frame_buffer_object() { + // Create Framebuffer + glGenFramebuffers(1, &frameBuffer); + glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer); + // Create color attachment + glGenTextures(1, &textureColorBuffer); + glBindTexture(GL_TEXTURE_2D, textureColorBuffer); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, screenTextureWidth, screenTextureHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureColorBuffer, 0); + // Create renderbuffer object for depth and stencil attachment + glGenRenderbuffers(1, &rbo); + glBindRenderbuffer(GL_RENDERBUFFER, rbo); + glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, screenTextureWidth, screenTextureHeight); + glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo); + // Check if framebuffer is complete + const bool success = glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE; + if (!success) { + ska_logger_error("Framebuffer is not complete!"); + } + glBindFramebuffer(GL_FRAMEBUFFER, 0); + return success; +} + +bool ska_frame_buffer_initialize(int32 inWindowWidth, int32 inWindowHeight, int32 inResolutionWidth, int32 inResolutionHeight) { + screenTextureWidth = inWindowWidth; + screenTextureHeight = inWindowHeight; + resolutionWidth = inResolutionWidth; + resolutionHeight = inResolutionHeight; + // VAO & VBO + // Initialize render data + glGenVertexArrays(1, &screenVAO); + glGenBuffers(1, &screenVBO); + glBindVertexArray(screenVAO); + glBindBuffer(GL_ARRAY_BUFFER, screenVBO); + // Set buffer data + GLfloat vertices[] = { + // pos // tex coords + -1.0f, 1.0f, 0.0f, 1.0f, + -1.0f, -1.0f, 0.0f, 0.0f, + 1.0f, -1.0f, 1.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 + }; + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); + // position attribute + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*) NULL); + // texture coords attribute + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)(2 * sizeof(GLfloat))); + + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindVertexArray(0); + + bool success = recreate_frame_buffer_object(); + + // compile shaders + SkaShader* screenShader = ska_shader_compile_new_shader(SKA_OPENGL_SHADER_SOURCE_VERTEX_SCREEN, + SKA_OPENGL_SHADER_SOURCE_FRAGMENT_SCREEN); + defaultScreenShader = (SkaShaderInstance) { + .shader = screenShader, .paramMap = ska_string_hash_map_create_default_capacity() + }; + ska_frame_buffer_set_screen_shader(&defaultScreenShader); + ska_frame_buffer_generate_viewport_data(inWindowWidth, inWindowHeight); + + hasBeenInitialized = true; + return success; +} + +void ska_frame_buffer_finalize() { + ska_string_hash_map_destroy(defaultScreenShader.paramMap); + defaultScreenShader.paramMap = NULL; + hasBeenInitialized = false; +} + +void ska_frame_buffer_bind() { + SKA_ASSERT(hasBeenInitialized); + glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer); +} + +void ska_frame_buffer_unbind() { + glBindFramebuffer(GL_FRAMEBUFFER, 0); +} + +uint32 ska_frame_buffer_get_color_buffer_texture() { + return textureColorBuffer; +} + +uint32 ska_frame_buffer_get_quad_vao() { + return screenVAO; +} + +void ska_frame_buffer_resize_texture(int32 newWidth, int32 newHeight) { + screenTextureWidth = newWidth; + screenTextureHeight = newHeight; + recreate_frame_buffer_object(); +} + +void ska_frame_buffer_set_maintain_aspect_ratio(bool shouldMaintainAspectRatio) { + maintainAspectRatio = shouldMaintainAspectRatio; +} + +SkaShaderInstance* ska_frame_buffer_get_screen_shader() { + return currentScreenShader; +} + +void ska_frame_buffer_set_screen_shader(struct SkaShaderInstance *shaderInstance) { + SKA_ASSERT_FMT(shaderInstance != NULL, "Trying to set screen shader to NULL!"); + currentScreenShader = shaderInstance; + ska_shader_use(currentScreenShader->shader); + ska_shader_set_int(currentScreenShader->shader, "TEXTURE", 0); +} + +void ska_frame_buffer_reset_to_default_screen_shader() { + currentScreenShader = &defaultScreenShader; +} + +#endif // #if SKA_RENDERING \ No newline at end of file diff --git a/seika/rendering/frame_buffer.h b/seika/rendering/frame_buffer.h new file mode 100644 index 0000000..0f6fd34 --- /dev/null +++ b/seika/rendering/frame_buffer.h @@ -0,0 +1,38 @@ +#pragma once + +#if SKA_RENDERING + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#include "seika/math/math.h" + +bool ska_frame_buffer_initialize(int32 inWindowWidth, int32 inWindowHeight, int32 inResolutionWidth, int32 inResolutionHeight); +void ska_frame_buffer_finalize(); +void ska_frame_buffer_bind(); +void ska_frame_buffer_unbind(); +uint32 ska_frame_buffer_get_color_buffer_texture(); +uint32 ska_frame_buffer_get_quad_vao(); +void ska_frame_buffer_resize_texture(int32 newWidth, int32 newHeight); +void ska_frame_buffer_set_maintain_aspect_ratio(bool shouldMaintainAspectRatio); + +struct SkaShaderInstance* ska_frame_buffer_get_screen_shader(); +void ska_frame_buffer_set_screen_shader(struct SkaShaderInstance* shaderInstance); +void ska_frame_buffer_reset_to_default_screen_shader(); + +typedef struct SkaFrameBufferViewportData { + SkaVector2i position; + SkaSize2Di size; +} SkaFrameBufferViewportData; + +SkaFrameBufferViewportData ska_frame_buffer_generate_viewport_data(int32 windowWidth, int32 windowHeight); +SkaFrameBufferViewportData* ska_frame_buffer_get_cached_viewport_data(); + +#ifdef __cplusplus +} +#endif + +#endif // #if SKA_RENDERING diff --git a/seika/rendering/render_context.c b/seika/rendering/render_context.c new file mode 100644 index 0000000..35de69e --- /dev/null +++ b/seika/rendering/render_context.c @@ -0,0 +1,27 @@ +#if SKA_RENDERING + +#include "render_context.h" + +#include + +#include "seika/memory.h" +#include "seika/assert.h" + +static SkaRenderContext* renderContext = NULL; + +void ska_render_context_initialize() { + SKA_ASSERT_FMT(renderContext == NULL, "Render context is already initialized!"); + renderContext = SKA_MEM_ALLOCATE(SkaRenderContext); +} + +void ska_render_context_finalize() { + SKA_ASSERT_FMT(renderContext != NULL, "Render context is not initialized!"); + SKA_MEM_FREE(renderContext); +} + +SkaRenderContext* ska_render_context_get() { + SKA_ASSERT_FMT(renderContext != NULL, "Render context is not initialized!"); + return renderContext; +} + +#endif // #if SKA_RENDERING diff --git a/seika/rendering/render_context.h b/seika/rendering/render_context.h new file mode 100644 index 0000000..4864306 --- /dev/null +++ b/seika/rendering/render_context.h @@ -0,0 +1,20 @@ +#pragma once + +#if SKA_RENDERING + +#include +#include FT_FREETYPE_H + +#include "seika/defines.h" + +typedef struct SkaRenderContext { + FT_Library freeTypeLibrary; + int32 windowWidth; + int32 windowHeight; +} SkaRenderContext; + +void ska_render_context_initialize(); +void ska_render_context_finalize(); +SkaRenderContext* ska_render_context_get(); + +#endif // #if SKA_RENDERING diff --git a/seika/rendering/renderer.c b/seika/rendering/renderer.c new file mode 100644 index 0000000..79fdea2 --- /dev/null +++ b/seika/rendering/renderer.c @@ -0,0 +1,614 @@ +#if SKA_RENDERING + +#include "renderer.h" + +#include +#include + +#include "render_context.h" +#include "shader/shader.h" +#include "shader/shader_cache.h" +#include "shader/shader_source.h" +#include "seika/assert.h" +#include "seika/logger.h" +#include "seika/data_structures/static_array.h" + +#define SKA_RENDER_TO_FRAMEBUFFER +#define SKA_RENDER_LAYER_BATCH_ITEM_MAX 1024 +#define SKA_RENDER_LAYER_FONT_BATCH_ITEM_MAX 100 +#define SKA_RENDER_TEXTURE_LAYER_TEXTURE_MAX 64 + +#ifdef SKA_RENDER_TO_FRAMEBUFFER +#include "frame_buffer.h" +#endif + +typedef struct SkaTextureCoordinates { + GLfloat sMin; + GLfloat sMax; + GLfloat tMin; + GLfloat tMax; +} SkaTextureCoordinates; + +static SkaTextureCoordinates renderer_get_texture_coordinates(const SkaTexture* texture, const SkaRect2* drawSource, bool flipH, bool flipV); +static void renderer_set_shader_instance_params(SkaShaderInstance* shaderInstance); +static void renderer_print_opengl_errors(); + +static void sprite_renderer_initialize(); +static void sprite_renderer_finalize(); +static void sprite_renderer_update_resolution(); + +static void font_renderer_initialize(); +static void font_renderer_finalize(); +static void font_renderer_update_resolution(); +static void font_renderer_draw_text(const SkaFont* font, const char* text, f32 x, f32 y, f32 scale, const SkaColor* color); + +static GLuint spriteQuadVAO; +static GLuint spriteQuadVBO; + +static SkaShader* spriteShader = NULL; +static SkaShader* fontShader = NULL; + +// Global Shader Params +static f32 globalShaderParamTime = 0.0f; + +static f32 resolutionWidth = 800.0f; +static f32 resolutionHeight = 600.0f; +static mat4 spriteProjection = { + {1.0f, 0.0f, 0.0f, 0.0f}, + {0.0f, 1.0f, 0.0f, 0.0f}, + {0.0f, 0.0f, 1.0f, 0.0f}, + {0.0f, 0.0f, 0.0f, 1.0f} +}; + +// Sprite Batching +typedef struct SpriteBatchItem { + SkaTexture* texture; + SkaRect2 sourceRect; + SkaSize2D destSize; + SkaColor color; + bool flipH; + bool flipV; + SkaRendererTransform2D transform2D; + SkaShaderInstance* shaderInstance; +} SpriteBatchItem; + +typedef struct FontBatchItem { + SkaFont* font; + const char* text; + f32 x; + f32 y; + f32 scale; + SkaColor color; +} FontBatchItem; + +void renderer_batching_draw_sprites(SpriteBatchItem items[], usize spriteCount); + +// Render Layer - Arranges draw order by z index +typedef struct RenderTextureLayer { + SpriteBatchItem spriteBatchItems[SKA_RENDER_LAYER_BATCH_ITEM_MAX]; + usize spriteBatchItemCount; +} RenderTextureLayer; + +typedef struct RenderLayer { + RenderTextureLayer renderTextureLayers[SKA_RENDER_TEXTURE_LAYER_TEXTURE_MAX]; + FontBatchItem fontBatchItems[SKA_RENDER_LAYER_FONT_BATCH_ITEM_MAX]; + usize renderTextureLayerCount; + usize fontBatchItemCount; +} RenderLayer; + +SKA_STATIC_ARRAY_CREATE(RenderLayer, SKA_RENDERER_MAX_Z_INDEX, render_layer_items); +SKA_STATIC_ARRAY_CREATE(int32, SKA_RENDERER_MAX_Z_INDEX, active_render_layer_items_indices); + +// Renderer +void ska_renderer_initialize(int32 inWindowWidth, int32 inWindowHeight, int32 inResolutionWidth, int32 inResolutionHeight, bool maintainAspectRatio) { + resolutionWidth = (f32)inResolutionWidth; + resolutionHeight = (f32)inResolutionHeight; + glEnable(GL_CULL_FACE); + glEnable(GL_BLEND); + glDisable(GL_MULTISAMPLE); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + ska_render_context_initialize(); + ska_renderer_update_window_size(inWindowWidth, inWindowHeight); + sprite_renderer_initialize(); + font_renderer_initialize(); + ska_shader_cache_initialize(); +#ifdef SKA_RENDER_TO_FRAMEBUFFER + // Initialize framebuffer + SKA_ASSERT_FMT(ska_frame_buffer_initialize(inWindowWidth, inWindowHeight, inResolutionWidth, inResolutionHeight), "Framebuffer didn't initialize!"); + ska_frame_buffer_set_maintain_aspect_ratio(maintainAspectRatio); +#endif + // Set initial data for render layer + for (usize i = 0; i < SKA_RENDERER_MAX_Z_INDEX; i++) { + render_layer_items[i].renderTextureLayerCount = 0; + render_layer_items[i].fontBatchItemCount = 0; + for (usize j = 0; j < SKA_RENDER_TEXTURE_LAYER_TEXTURE_MAX; j++) { + render_layer_items[i].renderTextureLayers[j].spriteBatchItemCount = 0; + } + } +} + +void ska_renderer_finalize() { + font_renderer_finalize(); + sprite_renderer_finalize(); + ska_render_context_finalize(); + ska_shader_cache_finalize(); +#ifdef SKA_RENDER_TO_FRAMEBUFFER + ska_frame_buffer_finalize(); +#endif +} + +void ska_renderer_update_window_size(int32 windowWidth, int32 windowHeight) { +#ifdef SKA_RENDER_TO_FRAMEBUFFER + const SkaFrameBufferViewportData data = ska_frame_buffer_generate_viewport_data(windowWidth, windowHeight); +#else + struct ViewportData { + SKAVector2i position; + SKASize2Di size; + }; + const struct ViewportData data = { .position = { .x = 0, .y = 0 }, .size = { .w = windowWidth, .h = windowHeight } }; +#endif + glViewport(data.position.x, data.position.y, data.size.w, data.size.h); + SkaRenderContext* renderContext = ska_render_context_get(); + renderContext->windowWidth = data.size.w; + renderContext->windowHeight = data.size.h; +#ifdef SKA_RENDER_TO_FRAMEBUFFER + ska_frame_buffer_resize_texture(data.size.w, data.size.h); +#endif +} + +static inline void update_active_render_layer_index(int32 zIndex) { + const usize sizeBefore = SKA_STATIC_ARRAY_SIZE(active_render_layer_items_indices); + SKA_STATIC_ARRAY_ADD_IF_UNIQUE(active_render_layer_items_indices, zIndex); + const usize sizeAfter = SKA_STATIC_ARRAY_SIZE(active_render_layer_items_indices); + if (sizeBefore != sizeAfter) { + SKA_STATIC_ARRAY_SORT_INT(active_render_layer_items_indices); + } +} + +static inline void ska_renderer_queue_sprite_draw_call(SpriteBatchItem* item, int32 zIndex) { + const int32 arrayZIndex = ska_math_clamp_int(zIndex + SKA_RENDERER_MAX_Z_INDEX / 2, 0, SKA_RENDERER_MAX_Z_INDEX - 1); + // Get texture layer index for render texture + usize textureLayerIndex = render_layer_items[arrayZIndex].renderTextureLayerCount; + for (usize i = 0; i < render_layer_items[arrayZIndex].renderTextureLayerCount; i++) { + if (item->texture == render_layer_items[arrayZIndex].renderTextureLayers[i].spriteBatchItems[0].texture && item->shaderInstance == render_layer_items[arrayZIndex].renderTextureLayers[i].spriteBatchItems[0].shaderInstance) { + textureLayerIndex = i; + break; + } + } + RenderTextureLayer* textureLayer = &render_layer_items[arrayZIndex].renderTextureLayers[textureLayerIndex]; + // Increment render texture layer count if first sprite + if (textureLayer->spriteBatchItemCount == 0) { + render_layer_items[arrayZIndex].renderTextureLayerCount++; + } + // Copy batch item into batch items array and increment item count + SKA_ASSERT_FMT(textureLayer->spriteBatchItemCount + 1 < SKA_RENDER_LAYER_BATCH_ITEM_MAX, "Exceeded SKA_RENDER_LAYER_BATCH_ITEM_MAX '%d'", SKA_RENDER_LAYER_BATCH_ITEM_MAX); + SpriteBatchItem* currentItem = &textureLayer->spriteBatchItems[textureLayer->spriteBatchItemCount++]; + memcpy(currentItem, item, sizeof(SpriteBatchItem)); + // Update active render layer indices + update_active_render_layer_index(arrayZIndex); +} + +void ska_renderer_queue_sprite_draw(SkaTexture* texture, SkaRect2 sourceRect, SkaSize2D destSize, SkaColor color, bool flipH, bool flipV, const SkaTransform2D* transform2D, int32 zIndex, SkaShaderInstance* shaderInstance) { + if (texture == NULL) { + ska_logger_error("NULL texture, not submitting draw call!"); + return; + } + SpriteBatchItem item = (SpriteBatchItem){ .texture = texture, .sourceRect = sourceRect, .destSize = destSize, .color = color, .flipH = flipH, .flipV = flipV, .transform2D = { .model = {{0}} }, .shaderInstance = shaderInstance }; + ska_transform2d_transform_to_mat4(transform2D, item.transform2D.model); + ska_renderer_queue_sprite_draw_call(&item, zIndex); +} + +void ska_renderer_queue_sprite_draw2(SkaTexture* texture, SkaRect2 sourceRect, SkaSize2D destSize, SkaColor color, bool flipH, bool flipV, mat4 trsMatrix, int32 zIndex, SkaShaderInstance* shaderInstance) { + if (texture == NULL) { + ska_logger_error("NULL texture, not submitting draw call!"); + return; + } + SpriteBatchItem item = (SpriteBatchItem){ .texture = texture, .sourceRect = sourceRect, .destSize = destSize, .color = color, .flipH = flipH, .flipV = flipV, .transform2D = { .model = {{0}} }, .shaderInstance = shaderInstance }; + glm_mat4_copy(trsMatrix, item.transform2D.model); + ska_renderer_queue_sprite_draw_call(&item, zIndex); +} + +void ska_renderer_queue_font_draw_call(SkaFont* font, const char* text, f32 x, f32 y, f32 scale, SkaColor color, int32 zIndex) { + if (font == NULL) { + ska_logger_error("NULL font, not submitting draw call!"); + return; + } + + FontBatchItem item = { .font = font, .text = text, .x = x, .y = y, .scale = scale, .color = color }; + const int32 arrayZIndex = ska_math_clamp_int(zIndex + SKA_RENDERER_MAX_Z_INDEX / 2, 0, SKA_RENDERER_MAX_Z_INDEX - 1); + // Update font batch item on render layer + render_layer_items[arrayZIndex].fontBatchItems[render_layer_items[arrayZIndex].fontBatchItemCount++] = item; + // Update active render layer indices + update_active_render_layer_index(arrayZIndex); +} + +static void ska_renderer_flush_batches() { + for (usize i = 0; i < active_render_layer_items_indices_count; i++) { + const usize layerIndex = active_render_layer_items_indices[i]; + // Sprite + for (usize renderTextureIndex = 0; renderTextureIndex < render_layer_items[layerIndex].renderTextureLayerCount; renderTextureIndex++) { + RenderTextureLayer* renderTextureLayer = &render_layer_items[layerIndex].renderTextureLayers[renderTextureIndex]; + renderer_batching_draw_sprites(renderTextureLayer->spriteBatchItems, renderTextureLayer->spriteBatchItemCount); + renderTextureLayer->spriteBatchItemCount = 0; + } + render_layer_items[layerIndex].renderTextureLayerCount = 0; + // Font + for (usize fontIndex = 0; fontIndex < render_layer_items[layerIndex].fontBatchItemCount; fontIndex++) { + font_renderer_draw_text( + render_layer_items[layerIndex].fontBatchItems[fontIndex].font, + render_layer_items[layerIndex].fontBatchItems[fontIndex].text, + render_layer_items[layerIndex].fontBatchItems[fontIndex].x, + render_layer_items[layerIndex].fontBatchItems[fontIndex].y, + render_layer_items[layerIndex].fontBatchItems[fontIndex].scale, + &render_layer_items[layerIndex].fontBatchItems[fontIndex].color + ); + } + render_layer_items[layerIndex].fontBatchItemCount = 0; + } + + SKA_STATIC_ARRAY_EMPTY(render_layer_items); + SKA_STATIC_ARRAY_EMPTY(active_render_layer_items_indices); +} + +void ska_renderer_process_and_flush_batches(const SkaColor* backgroundColor) { +#ifdef SKA_RENDER_TO_FRAMEBUFFER + ska_frame_buffer_bind(); +#endif + + // Clear framebuffer with background color + glClearColor(backgroundColor->r, backgroundColor->g, backgroundColor->b, backgroundColor->a); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); + +#ifdef SKA_RENDER_TO_FRAMEBUFFER + SkaFrameBufferViewportData* viewportData = ska_frame_buffer_get_cached_viewport_data(); + glViewport(0, 0, viewportData->size.w, viewportData->size.h); +#endif + + ska_renderer_flush_batches(); + +#ifdef SKA_RENDER_TO_FRAMEBUFFER + ska_frame_buffer_unbind(); + + // Clear screen texture background + static const SkaColor screenBackgroundColor = {0.0f, 0.0f, 0.0f, 1.0f }; + glClearColor(screenBackgroundColor.r, screenBackgroundColor.g, screenBackgroundColor.b, screenBackgroundColor.a); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + // Draw screen texture from framebuffer + SkaShaderInstance* screenShaderInstance = ska_frame_buffer_get_screen_shader(); + ska_shader_use(screenShaderInstance->shader); + + // Apply shader instance params + renderer_set_shader_instance_params(screenShaderInstance); + + glBindVertexArray(ska_frame_buffer_get_quad_vao()); + glViewport(viewportData->position.x, viewportData->position.y, viewportData->size.w, viewportData->size.h); + + glBindTexture(GL_TEXTURE_2D, ska_frame_buffer_get_color_buffer_texture()); // use the color attachment texture as the texture of the quad plane + glDrawArrays(GL_TRIANGLES, 0, 6); +#endif +} + +#ifdef SKA_RENDER_TO_FRAMEBUFFER +void ska_renderer_process_and_flush_batches_just_framebuffer(const SkaColor *backgroundColor) { + ska_frame_buffer_bind(); + + // Clear framebuffer with background color + glClearColor(backgroundColor->r, backgroundColor->g, backgroundColor->b, backgroundColor->a); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); + + ska_renderer_flush_batches(); + + ska_frame_buffer_unbind(); +} +#endif + +// --- Sprite Renderer --- // +#define VERTS_STRIDE 10 +void sprite_renderer_initialize() { + GLfloat vertices[] = { + //id (1) // positions (2) // texture coordinates (2) // color (4) // is pixel art (1) + 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, + + 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, + 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f + }; + + // Initialize render data + glGenVertexArrays(1, &spriteQuadVAO); + glGenBuffers(1, &spriteQuadVBO); + + glBindBuffer(GL_ARRAY_BUFFER, spriteQuadVBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_DYNAMIC_DRAW); + + glBindVertexArray(spriteQuadVAO); + // id attribute + glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, VERTS_STRIDE * sizeof(GLfloat), (void*) NULL); + glEnableVertexAttribArray(0); + // position attribute + glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, VERTS_STRIDE * sizeof(GLfloat), (GLvoid*)(sizeof(GLfloat))); + glEnableVertexAttribArray(1); + // texture coords attribute + glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, VERTS_STRIDE * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); + glEnableVertexAttribArray(2); + // color attribute + glVertexAttribPointer(3, 4, GL_FLOAT, GL_FALSE, VERTS_STRIDE * sizeof(GLfloat), (GLvoid*)(5 * sizeof(GLfloat))); + glEnableVertexAttribArray(3); + // is pixel art attribute + glVertexAttribPointer(4, 1, GL_FLOAT, GL_FALSE, VERTS_STRIDE * sizeof(GLfloat), (GLvoid*)(9 * sizeof(GLfloat))); + glEnableVertexAttribArray(4); + + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindVertexArray(0); + + // compile shaders + spriteShader = ska_shader_compile_new_shader(SKA_OPENGL_SHADER_SOURCE_VERTEX_SPRITE, + SKA_OPENGL_SHADER_SOURCE_FRAGMENT_SPRITE); + sprite_renderer_update_resolution(); + ska_renderer_set_sprite_shader_default_params(spriteShader); +} + +void sprite_renderer_finalize() {} + +void ska_renderer_set_sprite_shader_default_params(SkaShader* shader) { + ska_shader_use(shader); + ska_shader_set_int(shader, "TEXTURE", 0); + ska_shader_set_mat4_float(shader, "CRE_PROJECTION", &spriteProjection); +} + +void sprite_renderer_update_resolution() { + glm_mat4_identity(spriteProjection); + glm_ortho(0.0f, resolutionWidth, resolutionHeight, 0.0f, -1.0f, 1.0f, spriteProjection); +} + +void renderer_batching_draw_sprites(SpriteBatchItem items[], usize spriteCount) { +#define MAX_SPRITE_COUNT 2000 +#define NUMBER_OF_VERTICES 6 +#define VERTEX_BUFFER_SIZE (VERTS_STRIDE * NUMBER_OF_VERTICES * MAX_SPRITE_COUNT) + + if (spriteCount <= 0) { + return; + } + + SKA_ASSERT(spriteCount <= MAX_SPRITE_COUNT); + + glDepthMask(false); + + glBindVertexArray(spriteQuadVAO); + glBindBuffer(GL_ARRAY_BUFFER, spriteQuadVBO); + + SkaTexture* texture = items[0].texture; + + GLfloat verts[VERTEX_BUFFER_SIZE]; + for (usize i = 0; i < spriteCount; i++) { + if (items[i].shaderInstance != NULL) { + ska_shader_use(items[i].shaderInstance->shader); + renderer_set_shader_instance_params(items[i].shaderInstance); + } else { + ska_shader_use(spriteShader); + } + + glm_scale(items[i].transform2D.model, (vec3) { + items[i].destSize.w, items[i].destSize.h, 1.0f + }); + const f32 spriteId = (f32) i; + const f32 determinate = glm_mat4_det(items[i].transform2D.model); + const SkaTextureCoordinates textureCoords = renderer_get_texture_coordinates(texture, &items[i].sourceRect, items[i].flipH, items[i].flipV); + // concat CRE_MODELS[] string for uniform param + char modelsBuffer[24]; + sprintf(modelsBuffer, "CRE_MODELS[%zu]", i); + ska_shader_set_mat4_float(spriteShader, modelsBuffer, &items[i].transform2D.model); + + // Loop over vertices + for (int32 j = 0; j < NUMBER_OF_VERTICES; j++) { + bool isSMin; + bool isTMin; + if (determinate >= 0.0f) { + isSMin = j == 0 || j == 2 || j == 3; + isTMin = j == 1 || j == 2 || j == 5; + } else { + isSMin = j == 1 || j == 2 || j == 5; + isTMin = j == 0 || j == 2 || j == 3; + } + const int32 row = (j * VERTS_STRIDE) + ((int32) i * (VERTS_STRIDE * NUMBER_OF_VERTICES)); + verts[row + 0] = spriteId; + verts[row + 1] = isSMin ? 0.0f : 1.0f; + verts[row + 2] = isTMin ? 0.0f : 1.0f; + verts[row + 3] = isSMin ? textureCoords.sMin : textureCoords.sMax; + verts[row + 4] = isTMin ? textureCoords.tMin : textureCoords.tMax; + verts[row + 5] = items[i].color.r; + verts[row + 6] = items[i].color.g; + verts[row + 7] = items[i].color.b; + verts[row + 8] = items[i].color.a; + verts[row + 9] = (f32)texture->applyNearestNeighbor; + } + } + + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, texture->id); + + glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr) sizeof(verts), verts, GL_DYNAMIC_DRAW); + glDrawArrays(GL_TRIANGLES, 0, (GLsizei) (spriteCount * NUMBER_OF_VERTICES)); + + renderer_print_opengl_errors(); + + glBindVertexArray(0); + glDepthMask(true); + +#undef MAX_SPRITE_COUNT +#undef NUMBER_OF_VERTICES +#undef VERTEX_BUFFER_SIZE +} +#undef VERTS_STRIDE + +// --- Font Renderer --- // +void font_renderer_initialize() { + if (FT_Init_FreeType(&ska_render_context_get()->freeTypeLibrary)) { + ska_logger_error("Unable to initialize FreeType library!"); + } + fontShader = ska_shader_compile_new_shader(SKA_OPENGL_SHADER_SOURCE_VERTEX_FONT, + SKA_OPENGL_SHADER_SOURCE_FRAGMENT_FONT); + font_renderer_update_resolution(); +} + +void font_renderer_finalize() { + FT_Done_FreeType(ska_render_context_get()->freeTypeLibrary); +} + +void font_renderer_update_resolution() { + mat4 proj = { + {1.0f, 0.0f, 0.0f, 0.0f}, + {0.0f, 1.0f, 0.0f, 0.0f}, + {0.0f, 0.0f, 1.0f, 0.0f}, + {0.0f, 0.0f, 0.0f, 1.0f} + }; + glm_ortho(0.0f, resolutionWidth, -resolutionHeight, 0.0f, -1.0f, 1.0f, proj); + ska_shader_use(fontShader); + ska_shader_set_mat4_float(fontShader, "projection", &proj); +} + +void font_renderer_draw_text(const SkaFont* font, const char* text, f32 x, f32 y, f32 scale, const SkaColor* color) { + SkaVector2 currentScale = {scale, scale }; + ska_shader_use(fontShader); + ska_shader_set_vec4_float(fontShader, "textColor", color->r, color->g, color->b, color->a); + glActiveTexture(GL_TEXTURE0); + glBindVertexArray(font->VAO); + + // Iterate through all characters + char* c = (char*) &text[0]; + const usize textLength = strlen(text); + for (usize i = 0; i < textLength; i++) { + SkaFontCharacter ch = font->characters[(int32) *c]; + const f32 xPos = x + (ch.bearing.x * currentScale.x); + const f32 yPos = -y - (ch.size.y - ch.bearing.y) * currentScale.x; // Invert Y because orthographic projection is flipped + const f32 w = ch.size.x * currentScale.x; + const f32 h = ch.size.y * currentScale.y; + // Update VBO for each characters + GLfloat verts[6][4] = { + {xPos, yPos + h, 0.0f, 0.0f}, + {xPos, yPos, 0.0f, 1.0f}, + {xPos + w, yPos, 1.0f, 1.0f}, + + {xPos, yPos + h, 0.0f, 0.0f}, + {xPos + w, yPos, 1.0f, 1.0f}, + {xPos + w, yPos + h, 1.0f, 0.0f} + }; + // Render glyph texture over quad + glBindTexture(GL_TEXTURE_2D, ch.textureId); + // Update content of VBO memory + glBindBuffer(GL_ARRAY_BUFFER, font->VBO); + glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(verts), verts); + // Render + glDrawArrays(GL_TRIANGLES, 0, 6); + x += (f32) (ch.advance >> 6) * currentScale.x; // bitshift by 6 to get value in pixels (2^6 = 64 (divide amount of 1/64th pixels by 64 to get amount of pixels)) + ++c; + } + // Unbind + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindVertexArray(0); + glBindTexture(GL_TEXTURE_2D, 0); +} + +// --- Misc --- // +SkaTextureCoordinates renderer_get_texture_coordinates(const SkaTexture* texture, const SkaRect2* drawSource, bool flipH, bool flipV) { + GLfloat sMin = 0.0f; + GLfloat sMax = 1.0f; + GLfloat tMin = 0.0f; + GLfloat tMax = 1.0f; + // S + if (texture->width != (GLsizei)drawSource->w || texture->height != (GLsizei)drawSource->h) { + sMin = (drawSource->x + 0.5f) / (f32) texture->width; + sMax = (drawSource->x + drawSource->w - 0.5f) / (f32) texture->width; + tMin = (drawSource->y + 0.5f) / (f32) texture->height; + tMax = (drawSource->y + drawSource->h - 0.5f) / (f32) texture->height; + } + if (flipH) { + const GLfloat tempSMin = sMin; + sMin = sMax; + sMax = tempSMin; + } + if (flipV) { + const GLfloat tempTMin = tMin; + tMin = tMax; + tMax = tempTMin; + } + return (SkaTextureCoordinates) { + sMin, sMax, tMin, tMax + }; +} + +void renderer_set_shader_instance_params(SkaShaderInstance* shaderInstance) { + // Set global shader params first + ska_shader_set_float(shaderInstance->shader, "TIME", globalShaderParamTime); + + // Now set shader params specific to the shader instance + if (shaderInstance->paramsDirty && shaderInstance->paramMap->size > 0) { + SKA_STRING_HASH_MAP_FOR_EACH(shaderInstance->paramMap, iter) { + SkaStringHashMapNode* node = iter.pair; + SkaShaderParam* param = (SkaShaderParam*) node->value; + switch (param->type) { + case SkaShaderParamType_BOOL: { + ska_shader_set_bool(shaderInstance->shader, param->name, param->value.boolValue); + break; + } + case SkaShaderParamType_INT: { + ska_shader_set_int(shaderInstance->shader, param->name, param->value.intValue); + break; + } + case SkaShaderParamType_FLOAT: { + ska_shader_set_float(shaderInstance->shader, param->name, param->value.floatValue); + break; + } + case SkaShaderParamType_FLOAT2: { + ska_shader_set_vec2_float(shaderInstance->shader, param->name, param->value.float2Value.x,param->value.float2Value.y); + break; + } + case SkaShaderParamType_FLOAT3: { + ska_shader_set_vec3_float(shaderInstance->shader, param->name, param->value.float3Value.x,param->value.float3Value.y, param->value.float3Value.z); + break; + } + case SkaShaderParamType_FLOAT4: { + ska_shader_set_vec4_float(shaderInstance->shader, param->name, param->value.float4Value.x,param->value.float4Value.y, param->value.float4Value.z,param->value.float4Value.w); + break; + } + } + } + shaderInstance->paramsDirty = false; + } +} + +void renderer_print_opengl_errors() { + GLenum err; + while ((err = glGetError()) != GL_NO_ERROR) { + printf("err = %d\n", err); + switch (err) { + case GL_NO_ERROR: + printf("GL_NO_ERROR\n"); + break; + case GL_INVALID_ENUM: + printf("GL_INVALID_ENUM\n"); + break; + case GL_INVALID_VALUE: + printf("GL_INVALID_VALUE\n"); + break; + case GL_INVALID_OPERATION: + printf("GL_INVALID_OPERATION\n"); + break; + case GL_INVALID_FRAMEBUFFER_OPERATION: + printf("GL_INVALID_FRAMEBUFFER_OPERATION\n"); + break; + default: + printf("default\n"); + break; + } + } +} + +// Shader param stuff +void ska_renderer_set_global_shader_param_time(f32 timeValue) { + globalShaderParamTime = timeValue; +} + +#endif // #if SKA_RENDERING diff --git a/seika/rendering/renderer.h b/seika/rendering/renderer.h new file mode 100644 index 0000000..b0a6120 --- /dev/null +++ b/seika/rendering/renderer.h @@ -0,0 +1,39 @@ +#pragma once + +#if SKA_RENDERING + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#include "texture.h" +#include "font.h" +#include "shader/shader_instance.h" +#include "seika/math/math.h" + +#define SKA_RENDERER_MAX_Z_INDEX 200 + +typedef struct SkaRendererTransform2D { + mat4 model; +} SkaRendererTransform2D; + +void ska_renderer_initialize(int32 inWindowWidth, int32 inWindowHeight, int32 inResolutionWidth, int32 inResolutionHeight, bool maintainAspectRatio); +void ska_renderer_finalize(); +void ska_renderer_update_window_size(int32 windowWidth, int32 windowHeight); +void ska_renderer_set_sprite_shader_default_params(SkaShader* shader); +void ska_renderer_queue_sprite_draw(SkaTexture* texture, SkaRect2 sourceRect, SkaSize2D destSize, SkaColor color, bool flipH, bool flipV, const SkaTransform2D* transform2D, int32 zIndex, SkaShaderInstance* shaderInstance); +void ska_renderer_queue_sprite_draw2(SkaTexture* texture, SkaRect2 sourceRect, SkaSize2D destSize, SkaColor color, bool flipH, bool flipV, mat4 trsMatrix, int32 zIndex, SkaShaderInstance* shaderInstance); +void ska_renderer_queue_font_draw_call(SkaFont* font, const char* text, f32 x, f32 y, f32 scale, SkaColor color, int32 zIndex); +void ska_renderer_process_and_flush_batches(const SkaColor *backgroundColor); +void ska_renderer_process_and_flush_batches_just_framebuffer(const SkaColor *backgroundColor); + +// Shader params +void ska_renderer_set_global_shader_param_time(f32 timeValue); + +#ifdef __cplusplus +} +#endif + +#endif // #if SKA_RENDERING diff --git a/seika/rendering/shader/shader.c b/seika/rendering/shader/shader.c new file mode 100644 index 0000000..a2c0dcc --- /dev/null +++ b/seika/rendering/shader/shader.c @@ -0,0 +1,93 @@ +#if SKA_RENDERING + +#include "shader.h" + +#include "seika/logger.h" +#include "seika/memory.h" + +static bool shader_check_compile_errors(uint32 shaderId, const char* type); + +SkaShader* ska_shader_compile_new_shader(const char* vertexSource, const char* fragmentSource) { + SkaShader* shader = SKA_MEM_ALLOCATE(SkaShader); + GLuint vertex, fragment; + // vertex + vertex = glCreateShader(GL_VERTEX_SHADER); + glShaderSource(vertex, 1, &vertexSource, NULL); + glCompileShader(vertex); + shader_check_compile_errors(vertex, SKA_SHADER_VERTEX_TYPE); + // fragment + fragment = glCreateShader(GL_FRAGMENT_SHADER); + glShaderSource(fragment, 1, &fragmentSource, NULL); + glCompileShader(fragment); + if (!shader_check_compile_errors(vertex, SKA_SHADER_FRAGMENT_TYPE)) { + return NULL; + } + // attack and link shaders + shader->id = glCreateProgram(); + glAttachShader(shader->id, vertex); + glAttachShader(shader->id, fragment); + glLinkProgram(shader->id); + if (!shader_check_compile_errors(shader->id, SKA_SHADER_PROGRAM_TYPE)) { + return NULL; + } + glDeleteShader(vertex); + glDeleteShader(fragment); + return shader; +} + +void ska_shader_destroy(SkaShader* shader) { + SKA_MEM_FREE(shader); +} + +bool shader_check_compile_errors(uint32 shaderId, const char* type) { + GLint success; + char infoLog[1024]; + if(type == SKA_SHADER_PROGRAM_TYPE) { + glGetProgramiv(shaderId, GL_LINK_STATUS, &success); + if(!success) { + glGetProgramInfoLog(shaderId, 1024, NULL, infoLog); + ska_logger_error("Shader type '%s' linking failed!\nInfoLog = %s", type, &infoLog); + } + } else { + glGetShaderiv(shaderId, GL_COMPILE_STATUS, &success); + if(!success) { + glGetShaderInfoLog(shaderId, 1024, NULL, infoLog); + ska_logger_error("Shader type '%s' compilation failed!InfoLog = \n%s", type, &infoLog); + } + } + return success; +} + +void ska_shader_use(SkaShader* shader) { + glUseProgram(shader->id); +} + +void ska_shader_set_bool(SkaShader* shader, const char* name, bool value) { + glUniform1i(glGetUniformLocation(shader->id, name), (int32)value); +} + +void ska_shader_set_int(SkaShader* shader, const char* name, int32 value) { + glUniform1i(glGetUniformLocation(shader->id, name), value); +} + +void ska_shader_set_float(SkaShader* shader, const char* name, f32 value) { + glUniform1f(glGetUniformLocation(shader->id, name), value); +} + +void ska_shader_set_vec2_float(SkaShader* shader, const char* name, f32 v1, f32 v2) { + glUniform2f(glGetUniformLocation(shader->id, name), v1, v2); +} + +void ska_shader_set_vec3_float(SkaShader* shader, const char* name, f32 v1, f32 v2, f32 v3) { + glUniform3f(glGetUniformLocation(shader->id, name), v1, v2, v3); +} + +void ska_shader_set_vec4_float(SkaShader* shader, const char* name, f32 v1, f32 v2, f32 v3, f32 v4) { + glUniform4f(glGetUniformLocation(shader->id, name), v1, v2, v3, v4); +} + +void ska_shader_set_mat4_float(SkaShader* shader, const char* name, mat4* value) { + glUniformMatrix4fv(glGetUniformLocation(shader->id, name), 1, GL_FALSE, (f32*)value); +} + +#endif // #if SKA_RENDERING diff --git a/seika/rendering/shader/shader.h b/seika/rendering/shader/shader.h new file mode 100644 index 0000000..547cf30 --- /dev/null +++ b/seika/rendering/shader/shader.h @@ -0,0 +1,30 @@ +#pragma once + +#if SKA_RENDERING + +#include + +#include + +#include "seika/math/math.h" + +static const char* SKA_SHADER_VERTEX_TYPE = "VERTEX"; +static const char* SKA_SHADER_FRAGMENT_TYPE = "FRAGMENT"; +static const char* SKA_SHADER_PROGRAM_TYPE = "PROGRAM"; + +typedef struct SkaShader { + GLuint id; +} SkaShader; + +SkaShader* ska_shader_compile_new_shader(const char* vertexSource, const char* fragmentSource); +void ska_shader_destroy(SkaShader* shader); +void ska_shader_use(SkaShader* shader); +void ska_shader_set_bool(SkaShader* shader, const char* name, bool value); +void ska_shader_set_int(SkaShader* shader, const char* name, int32 value); +void ska_shader_set_float(SkaShader* shader, const char* name, f32 value); +void ska_shader_set_vec2_float(SkaShader* shader, const char* name, f32 v1, f32 v2); +void ska_shader_set_vec3_float(SkaShader* shader, const char* name, f32 v1, f32 v2, f32 v3); +void ska_shader_set_vec4_float(SkaShader* shader, const char* name, f32 v1, f32 v2, f32 v3, f32 v4); +void ska_shader_set_mat4_float(SkaShader* shader, const char* name, mat4* value); + +#endif // #if SKA_RENDERING diff --git a/seika/rendering/shader/shader_cache.c b/seika/rendering/shader/shader_cache.c new file mode 100644 index 0000000..951125f --- /dev/null +++ b/seika/rendering/shader/shader_cache.c @@ -0,0 +1,121 @@ +#if SKA_RENDERING + +#include "shader_cache.h" + +#include + +#include "shader_file_parser.h" +#include "seika/memory.h" +#include "seika/assert.h" +#include "seika/asset/asset_file_loader.h" +#include "seika/data_structures/queue.h" +#include "seika/logger.h" + +// --- Parsed Shader Cache --- // +typedef struct SkaParsedShaderCacheItem { + SkaShaderFileParseResult parseResult; +} SkaParsedShaderCacheItem; + +SkaStringHashMap* parsedShaderCacheMap = NULL; + +// --- Shader Cache --- // +static SkaShaderInstance* instanceCache[SKA_SHADER_INSTANCE_MAX_INSTANCES]; +static SkaQueue* shaderInstanceIdQueue = NULL; + +void ska_shader_cache_initialize() { + SKA_ASSERT(shaderInstanceIdQueue == NULL); + SKA_ASSERT(parsedShaderCacheMap == NULL); + shaderInstanceIdQueue = ska_queue_create(SKA_SHADER_INSTANCE_MAX_INSTANCES, SKA_SHADER_INSTANCE_INVALID_ID); + for (uint32_t i = 0; i < SKA_SHADER_INSTANCE_MAX_INSTANCES; i++) { + ska_queue_enqueue(shaderInstanceIdQueue, i); + instanceCache[i] = NULL; + } + parsedShaderCacheMap = ska_string_hash_map_create_default_capacity(); +} + +void ska_shader_cache_finalize() { + SKA_ASSERT(shaderInstanceIdQueue != NULL); + SKA_ASSERT(parsedShaderCacheMap != NULL); + ska_queue_destroy(shaderInstanceIdQueue); + shaderInstanceIdQueue = NULL; + SKA_STRING_HASH_MAP_FOR_EACH(parsedShaderCacheMap, iter) { + SkaStringHashMapNode* node = iter.pair; + SkaParsedShaderCacheItem* cacheItem = (SkaParsedShaderCacheItem*)node->value; + ska_shader_file_parse_clear_parse_result(&cacheItem->parseResult); + } + ska_string_hash_map_destroy(parsedShaderCacheMap); + parsedShaderCacheMap = NULL; +} + +SkaShaderInstanceId ska_shader_cache_add_instance(SkaShaderInstance* instance) { + const SkaShaderInstanceId newId = ska_queue_dequeue(shaderInstanceIdQueue); + instanceCache[newId] = instance; + return newId; +} + +void ska_shader_cache_remove_instance(SkaShaderInstanceId instanceId) { + instanceCache[instanceId] = NULL; + ska_queue_enqueue(shaderInstanceIdQueue, instanceId); +} + +SkaShaderInstance* ska_shader_cache_get_instance(SkaShaderInstanceId instanceId) { + return instanceCache[instanceId]; +} + +SkaShaderInstance* ska_shader_cache_get_instance_checked(SkaShaderInstanceId instanceId) { + if (instanceId != SKA_SHADER_INSTANCE_INVALID_ID) { + return instanceCache[instanceId]; + } + return NULL; +} + +SkaShaderInstanceId ska_shader_cache_create_instance_and_add(const char* shaderPath) { + if (!ska_string_hash_map_has(parsedShaderCacheMap, shaderPath)) { + char* shaderSource = ska_asset_file_loader_read_file_contents_as_string_without_raw(shaderPath, NULL); + // Uncomment when needing to debug shaders +// se_logger_debug("shader source = \n%s", shaderSource); + if (shaderSource) { + SkaParsedShaderCacheItem newCacheItem; + newCacheItem.parseResult = ska_shader_file_parser_parse_shader(shaderSource); + const bool hasErrorMessage = strlen(newCacheItem.parseResult.errorMessage) > 0; + if (hasErrorMessage) { + ska_logger_error("Shader parse error = '%s'\n", newCacheItem.parseResult.errorMessage); + return SKA_SHADER_INSTANCE_INVALID_ID; + } + ska_string_hash_map_add(parsedShaderCacheMap, shaderPath, &newCacheItem, sizeof(SkaParsedShaderCacheItem)); + } else { + ska_logger_error("Failed to read shader source from '%s'", shaderPath); + return SKA_SHADER_INSTANCE_INVALID_ID; + } + } + + SkaParsedShaderCacheItem* cacheItem = (SkaParsedShaderCacheItem*)ska_string_hash_map_get(parsedShaderCacheMap, shaderPath); + SkaShader* newShader = ska_shader_compile_new_shader(cacheItem->parseResult.parseData.fullVertexSource, cacheItem->parseResult.parseData.fullFragmentSource); + if (newShader == NULL) { + ska_logger_error("Error compiling shader from path = '%s'\n", shaderPath); + return SKA_SHADER_INSTANCE_INVALID_ID; + } + SkaShaderInstance* shaderInstance = ska_shader_instance_create_from_shader(newShader); + for (usize i = 0; i < cacheItem->parseResult.parseData.uniformCount; i++) { + ska_shader_instance_param_create_from_copy(shaderInstance, &cacheItem->parseResult.parseData.uniforms[i]); + } + SkaShaderInstanceId newId = ska_shader_cache_add_instance(shaderInstance); + return newId; +} + +SkaShaderInstanceId ska_shader_cache_create_instance_and_add_from_raw(const char* vertexPath, const char* fragmentPath) { + char* vertexSource = ska_asset_file_loader_read_file_contents_as_string(vertexPath, NULL); + char* fragmentSource = ska_asset_file_loader_read_file_contents_as_string(fragmentPath, NULL); + const SkaShaderInstanceId newId = ska_shader_cache_create_instance_and_add_from_source(vertexSource, fragmentSource); + SKA_MEM_FREE(vertexSource); + SKA_MEM_FREE(fragmentSource); + return newId; +} + +SkaShaderInstanceId ska_shader_cache_create_instance_and_add_from_source(const char* vertexSource, const char* fragmentSource) { + SkaShaderInstance* instance = ska_shader_instance_create(vertexSource, fragmentSource); + const SkaShaderInstanceId newId = ska_shader_cache_add_instance(instance); + return newId; +} + +#endif // #if SKA_RENDERING diff --git a/seika/rendering/shader/shader_cache.h b/seika/rendering/shader/shader_cache.h new file mode 100644 index 0000000..459a7f3 --- /dev/null +++ b/seika/rendering/shader/shader_cache.h @@ -0,0 +1,23 @@ +#pragma once + +#if SKA_RENDERING + +#include "shader_instance_minimal.h" +#include "shader_instance.h" + +// Holds references to all custom shaders + +void ska_shader_cache_initialize(); +void ska_shader_cache_finalize(); + +SkaShaderInstanceId ska_shader_cache_add_instance(SkaShaderInstance* instance); +void ska_shader_cache_remove_instance(SkaShaderInstanceId instanceId); +SkaShaderInstance* ska_shader_cache_get_instance(SkaShaderInstanceId instanceId); +SkaShaderInstance* ska_shader_cache_get_instance_checked(SkaShaderInstanceId instanceId); +// Expects .shader files which contain vertex and fragment implementations +SkaShaderInstanceId ska_shader_cache_create_instance_and_add(const char* shaderPath); +// Should be a modification to the base shaders found in 'shader_source.h' +SkaShaderInstanceId ska_shader_cache_create_instance_and_add_from_raw(const char* vertexPath, const char* fragmentPath); +SkaShaderInstanceId ska_shader_cache_create_instance_and_add_from_source(const char* vertexSource, const char* fragmentSource); + +#endif // #if SKA_RENDERING diff --git a/seika/rendering/shader/shader_file_parser.c b/seika/rendering/shader/shader_file_parser.c new file mode 100644 index 0000000..5b9a3ba --- /dev/null +++ b/seika/rendering/shader/shader_file_parser.c @@ -0,0 +1,611 @@ +#if SKA_RENDERING + +#include "shader_file_parser.h" + +#include + +#include "shader_source.h" +#include "seika/string.h" +#include "seika/memory.h" + +#define SHADER_FILE_PARSER_ERROR_RETURN(RESULT, SOURCE, MESSAGE) \ +ska_strcpy((RESULT).errorMessage, (MESSAGE)); \ +SKA_MEM_FREE((SOURCE)); \ +return (RESULT); + +#define SHADER_FILE_PARSER_ERROR_FMT_RETURN(RESULT, SOURCE, FMT, ...) \ +sprintf((RESULT).errorMessage, (FMT), ##__VA_ARGS__); \ +SKA_MEM_FREE((SOURCE)); \ +return (RESULT); + +static char* shader_file_parse_data_get_full_uniforms_source(SkaShaderFileParseData* parseData) { + if (parseData->uniformCount == 0) { + return NULL; + } + char uniformsBuffer[1024]; + uniformsBuffer[0] = '\0'; + for (usize i = 0; i < parseData->uniformCount; i++) { + ska_strcat(uniformsBuffer, "uniform "); + switch (parseData->uniforms[i].type) { + case SkaShaderParamType_BOOL: { + ska_strcat(uniformsBuffer, "bool "); + break; + } + case SkaShaderParamType_INT: { + ska_strcat(uniformsBuffer, "int "); + break; + } + case SkaShaderParamType_FLOAT: { + ska_strcat(uniformsBuffer, "float "); + break; + } + case SkaShaderParamType_FLOAT2: { + ska_strcat(uniformsBuffer, "vec2 "); + break; + } + case SkaShaderParamType_FLOAT3: { + ska_strcat(uniformsBuffer, "vec3 "); + break; + } + case SkaShaderParamType_FLOAT4: { + ska_strcat(uniformsBuffer, "vec4 "); + break; + } + default: + break; + } + ska_strcat(uniformsBuffer, parseData->uniforms[i].name); + ska_strcat(uniformsBuffer, ";\n"); + } + return ska_strdup(uniformsBuffer); +} + +char* shader_file_parse_data_get_full_functions_source(SkaShaderFileParseData* parseData) { + if (parseData->functionCount == 0) { + return NULL; + } + char functionsBuffer[4096]; + functionsBuffer[0] = '\0'; + for (usize i = 0; i < parseData->functionCount; i++) { + ska_strcat(functionsBuffer, parseData->functions[i].fullFunctionSource); + ska_strcat(functionsBuffer, "\n"); + } + return ska_strdup(functionsBuffer); +} + +void shader_file_parse_data_delete_internal_memory(SkaShaderFileParseData* parseData) { + SKA_MEM_FREE(parseData->fullVertexSource); + SKA_MEM_FREE(parseData->fullFragmentSource); + for (usize i = 0; i < parseData->functionCount; i++) { + SKA_MEM_FREE(parseData->functions[i].name); + SKA_MEM_FREE(parseData->functions[i].fullFunctionSource); + } +} + +// Will parse the next token, returns true if there is more source to parse +bool shader_file_find_next_token(char** shaderSource, char* tokenOut, bool* semiColonFound) { + tokenOut[0] = '\0'; + + if (semiColonFound) { + *semiColonFound = false; + } + + int tokenIndex = 0; + while (*(*shaderSource) != '\0') { + if (*(*shaderSource) == ' ' || *(*shaderSource) == ';') { + if (semiColonFound && *(*shaderSource) == ';') { + *semiColonFound = true; + } + (*shaderSource)++; + tokenOut[tokenIndex] = '\0'; + return true; + } + if (*(*shaderSource) != '\n') { + tokenOut[tokenIndex++] = *(*shaderSource); + } + (*shaderSource)++; + } + return false; +} + +// Continue parsing shader source and returns 'true' if an '=' was found +bool shader_file_find_next_uniform_equals_token(char** shaderSource) { + while (*(*shaderSource) != '\0') { + if (*(*shaderSource) == '=') { + (*shaderSource)++; + return true; + } + (*shaderSource)++; + } + return false; +} + +bool shader_file_find_next_uniform_default_value(char** shaderSource, char* tokenOut, bool* semiColonFound) { + tokenOut[0] = '\0'; + + if (semiColonFound) { + *semiColonFound = false; + } + + int tokenIndex = 0; + while (*(*shaderSource) != '\0') { + if (*(*shaderSource) == ';') { + if (semiColonFound) { + *semiColonFound = true; + } + (*shaderSource)++; + tokenOut[tokenIndex] = '\0'; + return true; + } + if (*(*shaderSource) != '\n' && *(*shaderSource) != ' ') { + tokenOut[tokenIndex++] = *(*shaderSource); + } + (*shaderSource)++; + } + return false; +} + +SkaShaderFileParserFunction shader_file_find_next_function(char** shaderSource, const char* functionReturnType) { + SkaShaderFileParserFunction parsedFunction = { .name = NULL, .fullFunctionSource = NULL }; + char shaderFunctionBuffer[1024]; + ska_strcpy(shaderFunctionBuffer, functionReturnType); + ska_strcat(shaderFunctionBuffer, " "); + usize bufferIndex = strlen(shaderFunctionBuffer); + + // Get name first + char shaderFunctionName[64]; + unsigned int shaderFunctionNameIndex = 0; + while (*(*shaderSource) != '\0') { + shaderFunctionBuffer[bufferIndex++] = *(*shaderSource); + if (*(*shaderSource) != ' ') { + shaderFunctionName[shaderFunctionNameIndex++] = *(*shaderSource); + } + (*shaderSource)++; + if (*(*shaderSource) == '(') { + shaderFunctionName[shaderFunctionNameIndex] = '\0'; + break; + } + } + // Now just loop through until we encounter a '}' + usize openBracketsCount = 0; + while (*(*shaderSource) != '\0') { + shaderFunctionBuffer[bufferIndex++] = *(*shaderSource); + (*shaderSource)++; + if (*(*shaderSource) == '{') { + openBracketsCount++; + } else if (*(*shaderSource) == '}') { + shaderFunctionBuffer[bufferIndex++] = *(*shaderSource); + (*shaderSource)++; + openBracketsCount--; + if (openBracketsCount == 0) { + shaderFunctionBuffer[bufferIndex] = '\0'; + break; + } + } + } + + parsedFunction.name = ska_strdup(shaderFunctionName); + parsedFunction.fullFunctionSource = ska_strdup(shaderFunctionBuffer); + return parsedFunction; +} + +// Should have a valid function at this point... +char* shader_file_parse_function_body(const char* functionSource) { + char shaderFunctionBuffer[1024]; + shaderFunctionBuffer[0] = '\0'; + ska_strcpy(shaderFunctionBuffer, functionSource); + unsigned int functionBufferIndex = 0; + char currentToken = shaderFunctionBuffer[functionBufferIndex]; + // Find beginning body + while (currentToken != '{') { + currentToken = shaderFunctionBuffer[++functionBufferIndex]; + } + char functionBodyBuffer[1024]; + unsigned int functionBodyIndex = 0; + currentToken = shaderFunctionBuffer[++functionBufferIndex]; + // Return NULL if an empty function with (with no newlines at least) + if (currentToken == '}') { + return NULL; + } + usize openBracketsCount = 1; + while (openBracketsCount > 0) { + currentToken = shaderFunctionBuffer[functionBufferIndex++]; + functionBodyBuffer[functionBodyIndex++] = currentToken; + if (currentToken == '{') { + openBracketsCount++; + } else if (currentToken == '}') { + openBracketsCount--; + } + } + functionBodyBuffer[functionBodyIndex - 1] = '\n'; + functionBodyBuffer[functionBodyIndex] = '\0'; + + return ska_strdup(functionBodyBuffer); +} + +typedef struct ShaderFileParseVecParseResult { + SkaVector4 vector; + char errorMessage[64]; +} ShaderFileParseVecParseResult; + +// TODO: Refactor and make shorter... +ShaderFileParseVecParseResult shader_file_parse_vec_default_value_token(const char* token) { + ShaderFileParseVecParseResult result = { .vector = { .x = 0.0f, .y = 0.0f, .z = 0.0f, .w = 0.0f }, + .errorMessage = {0} + }; + unsigned int sourceTokenIndex = 4; + char currentFloat2Token = token[sourceTokenIndex]; + // TODO: Add more validation + if (currentFloat2Token != '(') { + ska_strcpy(result.errorMessage, "Didn't find '(' where expected for vec default value!"); + return result; + } + + // Now parse the first vector value + char float2Buffer[16]; + unsigned int float2BufferIndex = 0; + currentFloat2Token = token[++sourceTokenIndex]; + bool hasMoreThanOneValue = false; + while (currentFloat2Token != ')') { + if (currentFloat2Token == ',') { + hasMoreThanOneValue = true; + break; + } + float2Buffer[float2BufferIndex++] = currentFloat2Token; + currentFloat2Token = token[++sourceTokenIndex]; + } + float2Buffer[float2BufferIndex] = '\0'; + result.vector.x = strtof(float2Buffer, NULL); + + // Early out if one value + if (!hasMoreThanOneValue) { + result.vector.y = result.vector.x; + result.vector.z = result.vector.x; + result.vector.w = result.vector.x; + return result; + } + + // Now parse the rest of the values + float* vectorValues[3] = { &result.vector.y, &result.vector.z, &result.vector.w }; + unsigned int vectorValuesIndex = 0; + float2BufferIndex = 0; + currentFloat2Token = token[++sourceTokenIndex]; + // Probably should limit this and have a better termination criterion for loop + while (true) { + if (currentFloat2Token == ',' || currentFloat2Token == ')') { + float2Buffer[float2BufferIndex] = '\0'; + *vectorValues[vectorValuesIndex++] = strtof(float2Buffer, NULL); + if (currentFloat2Token == ')') { + break; + } + float2BufferIndex = 0; + currentFloat2Token = token[++sourceTokenIndex]; + } + float2Buffer[float2BufferIndex++] = currentFloat2Token; + currentFloat2Token = token[++sourceTokenIndex]; + } + + return result; +} + +bool shader_file_is_function_return_type_token(const char* token) { + return strcmp(token, "void") == 0 || strcmp(token, "bool") == 0 || strcmp(token, "int") == 0 + || strcmp(token, "float") == 0 || strcmp(token, "vec2") == 0 || strcmp(token, "vec3") == 0 + || strcmp(token, "vec4") == 0; +} + +typedef struct SEShaderFileParseBaseText { + const char* vertex; + const char* fragment; +} SEShaderFileParseBaseText; + +SEShaderFileParseBaseText shader_file_get_base_shader_text(SkaShaderInstanceType shaderType) { + switch (shaderType) { + case SkaShaderInstanceType_SCREEN: { + return (SEShaderFileParseBaseText) { + .vertex = SKA_OPENGL_SHADER_SOURCE_VERTEX_SCREEN, + .fragment = SKA_OPENGL_SHADER_SOURCE_FRAGMENT_SCREEN + }; + } + case SkaShaderInstanceType_SPRITE: { + return (SEShaderFileParseBaseText) { + .vertex = SKA_OPENGL_SHADER_SOURCE_VERTEX_SPRITE, + .fragment = SKA_OPENGL_SHADER_SOURCE_FRAGMENT_SPRITE + }; + } + default: + break; + } + return (SEShaderFileParseBaseText) { + .vertex = NULL, .fragment = NULL + }; +} + +// TODO: Check to make sure memory is cleaned up on errors +SkaShaderFileParseResult ska_shader_file_parser_parse_shader(const char* shaderSource) { + SkaShaderFileParseResult result = {.errorMessage = {0}}; + char *originalSource = ska_strdup(shaderSource); + char *currentSource = originalSource; + char shaderToken[32]; + bool isSemicolonFound; + result.parseData = (SkaShaderFileParseData) { + .shaderType = SkaShaderInstanceType_INVALID, + .fullVertexSource = NULL, + .fullFragmentSource = NULL, .vertexFunctionSource = NULL, + .fragmentFunctionSource = NULL, + .uniformCount = 0, + .functionCount = 0 + }; + + // Parse shader type + shader_file_find_next_token(¤tSource, shaderToken, &isSemicolonFound); + if (strcmp(shaderToken, "shader_type") != 0) { + SHADER_FILE_PARSER_ERROR_FMT_RETURN(result, originalSource, "Didn't find 'shader_type' first line! Found '%s'", shaderToken); + } + // Parse shader type value + shader_file_find_next_token(¤tSource, shaderToken, &isSemicolonFound); + if (strcmp(shaderToken, "screen") == 0) { + result.parseData.shaderType = SkaShaderInstanceType_SCREEN; + } else if (strcmp(shaderToken, "sprite") == 0) { + result.parseData.shaderType = SkaShaderInstanceType_SPRITE; + } else { + SHADER_FILE_PARSER_ERROR_FMT_RETURN(result, originalSource, "Didn't find 'shader_type' value on first line, instead found '%s'!", shaderToken); + } + + // Parse the rest + while (shader_file_find_next_token(¤tSource, shaderToken, &isSemicolonFound)) { + // UNIFORM VARIABLE + if (strcmp(shaderToken, "uniform") == 0) { +// printf("Parsing shader uniform variable\n"); + SkaShaderParam shaderUniform; + // Parse uniform type + char shaderUniformTypeName[32]; + shader_file_find_next_token(¤tSource, shaderUniformTypeName, &isSemicolonFound); + if (strcmp(shaderUniformTypeName, "bool") == 0) { + shaderUniform.type = SkaShaderParamType_BOOL; + shaderUniform.value.boolValue = false; + } else if (strcmp(shaderUniformTypeName, "int") == 0) { + shaderUniform.type = SkaShaderParamType_INT; + shaderUniform.value.intValue = 0; + } else if (strcmp(shaderUniformTypeName, "float") == 0) { + shaderUniform.type = SkaShaderParamType_FLOAT; + shaderUniform.value.floatValue = 0.0f; + } else if (strcmp(shaderUniformTypeName, "vec2") == 0) { + shaderUniform.type = SkaShaderParamType_FLOAT2; + shaderUniform.value.float2Value = (SkaVector2) { + 0.0f, 0.0f + }; + } else if (strcmp(shaderUniformTypeName, "vec3") == 0) { + shaderUniform.type = SkaShaderParamType_FLOAT3; + shaderUniform.value.float3Value = (SkaVector3) { + 0.0f, 0.0f, 0.0f + }; + } else if (strcmp(shaderUniformTypeName, "vec4") == 0) { + shaderUniform.type = SkaShaderParamType_FLOAT4; + shaderUniform.value.float4Value = (SkaVector4) { + 0.0f, 0.0f, 0.0f, 0.0f + }; + } else { + SHADER_FILE_PARSER_ERROR_FMT_RETURN(result, originalSource, "Expected to find uniform shader type, instead found '%s'!", shaderToken); + } +// printf("type = '%s'\n", shaderUniformTypeName); + // Parse uniform name + char shaderUniformName[32]; + shader_file_find_next_token(¤tSource, shaderUniformName, &isSemicolonFound); + shaderUniform.name = ska_strdup(shaderUniformName); +// printf("name = '%s'\n", shaderUniformName); + // If we didn't find the semicolon, parse for default value + if (!isSemicolonFound) { +// printf("Parsing shader default value\n"); + // Look for '=' + if (!shader_file_find_next_uniform_equals_token(¤tSource)) { + SHADER_FILE_PARSER_ERROR_FMT_RETURN(result, originalSource, "Expected to find an '=' when declaring a uniform variable, instead found '%s'!", shaderToken); + } +// printf("Found '='!\n"); + // Now parse default value + char shaderUniformDefaultValue[32]; + shader_file_find_next_uniform_default_value(¤tSource, shaderUniformDefaultValue, &isSemicolonFound); + if (!isSemicolonFound) { + SHADER_FILE_PARSER_ERROR_FMT_RETURN(result, originalSource, "Expected to find a ';' after declaring a uniform variable's default value, found '%s'!", shaderToken); + } +// printf("shader uniform default value = '%s'\n", shaderUniformDefaultValue); + switch (shaderUniform.type) { + case SkaShaderParamType_BOOL: { + // xor to set to false if default value is either 'false' or '0' + shaderUniform.value.boolValue = !(strcmp(shaderUniformDefaultValue, "false") == 0 || strcmp(shaderUniformDefaultValue, "0") == 0); + break; + } + case SkaShaderParamType_INT: { + char* endptr = NULL; + shaderUniform.value.intValue = (int) strtol(shaderUniformDefaultValue, &endptr, 10); + if (*endptr != '\0') { + SHADER_FILE_PARSER_ERROR_FMT_RETURN(result, originalSource, "Not a valid uniform int default value, found '%s'!", shaderToken); + } + break; + } + case SkaShaderParamType_FLOAT: { + shaderUniform.value.floatValue = strtof(shaderUniformDefaultValue, NULL); + break; + } + case SkaShaderParamType_FLOAT2: { + const ShaderFileParseVecParseResult vectorResult = shader_file_parse_vec_default_value_token(shaderUniformDefaultValue); + shaderUniform.value.float2Value.x = vectorResult.vector.x; + shaderUniform.value.float2Value.y = vectorResult.vector.y; + break; + } + case SkaShaderParamType_FLOAT3: { + const ShaderFileParseVecParseResult vectorResult = shader_file_parse_vec_default_value_token(shaderUniformDefaultValue); + shaderUniform.value.float3Value.x = vectorResult.vector.x; + shaderUniform.value.float3Value.y = vectorResult.vector.y; + shaderUniform.value.float3Value.z = vectorResult.vector.z; + break; + } + case SkaShaderParamType_FLOAT4: { + const ShaderFileParseVecParseResult vectorResult = shader_file_parse_vec_default_value_token(shaderUniformDefaultValue); + shaderUniform.value.float4Value.x = vectorResult.vector.x; + shaderUniform.value.float4Value.y = vectorResult.vector.y; + shaderUniform.value.float4Value.z = vectorResult.vector.z; + shaderUniform.value.float4Value.w = vectorResult.vector.w; + break; + } + default: + break; + } + } + // Finally after all validation checks, add new uniform to array + result.parseData.uniforms[result.parseData.uniformCount++] = shaderUniform; + } else if (shader_file_is_function_return_type_token(shaderToken)) { + SkaShaderFileParserFunction parsedFunction = shader_file_find_next_function(¤tSource, shaderToken); + if (parsedFunction.name == NULL || parsedFunction.fullFunctionSource == NULL) { + SHADER_FILE_PARSER_ERROR_RETURN(result, originalSource, "Didn't successfully parse shader function!"); + } +// printf("function name = '%s'\n", parsedFunction.name); +// printf("function source = '%s'\n", parsedFunction.fullFunctionSource); + // Check for vertex and fragment shader functions + if (strcmp(parsedFunction.name, "vertex") == 0) { + result.parseData.vertexFunctionSource = shader_file_parse_function_body(parsedFunction.fullFunctionSource); + SKA_MEM_FREE(parsedFunction.name); + SKA_MEM_FREE(parsedFunction.fullFunctionSource); + } else if (strcmp(parsedFunction.name, "fragment") == 0) { + result.parseData.fragmentFunctionSource = shader_file_parse_function_body(parsedFunction.fullFunctionSource); + SKA_MEM_FREE(parsedFunction.name); + SKA_MEM_FREE(parsedFunction.fullFunctionSource); + } else { + // Add non vertex and fragment functions to our array + result.parseData.functions[result.parseData.functionCount++] = parsedFunction; + } + } else { + SHADER_FILE_PARSER_ERROR_FMT_RETURN(result, originalSource, "Unexpected token '%s'!", shaderToken); + } + } + + // Now that we've parsed everything create vertex and fragment source text + const char* SHADER_UNIFORMS_REPLACE_TOKEN = "//@@UNIFORMS\n"; + const char* SHADER_FUNCTIONS_REPLACE_TOKEN = "//@@FUNCTIONS\n"; + const char* SHADER_VERTEX_BODY_REPLACE_TOKEN = "//@@vertex()\n"; + const char* SHADER_FRAGMENT_BODY_REPLACE_TOKEN = "//@@fragment()\n"; + const usize SHADER_UNIFORMS_REPLACE_TOKEN_LENGTH = strlen(SHADER_UNIFORMS_REPLACE_TOKEN); + const usize SHADER_FUNCTIONS_REPLACE_TOKEN_LENGTH = strlen(SHADER_FUNCTIONS_REPLACE_TOKEN); + const usize SHADER_VERTEX_BODY_REPLACE_TOKEN_LENGTH = strlen(SHADER_VERTEX_BODY_REPLACE_TOKEN); + const usize SHADER_FRAGMENT_BODY_REPLACE_TOKEN_LENGTH = strlen(SHADER_FRAGMENT_BODY_REPLACE_TOKEN); + + const SEShaderFileParseBaseText shaderBaseText = shader_file_get_base_shader_text(result.parseData.shaderType); + char fullShaderBuffer[4096]; + // Create vertex source + ska_strcpy(fullShaderBuffer, shaderBaseText.vertex); + if (result.parseData.vertexFunctionSource) { + // Vertex uniforms + char* foundUniformsToken = strstr(fullShaderBuffer, SHADER_UNIFORMS_REPLACE_TOKEN); + if (!foundUniformsToken) { + SHADER_FILE_PARSER_ERROR_RETURN(result, originalSource, "Unable to find uniforms token in vertex shader!"); + } + char* uniformsSource = shader_file_parse_data_get_full_uniforms_source(&result.parseData); + if (uniformsSource) { + const usize uniformsReplaceLength = strlen(uniformsSource); + memmove(foundUniformsToken + uniformsReplaceLength, + foundUniformsToken + SHADER_UNIFORMS_REPLACE_TOKEN_LENGTH, + strlen(foundUniformsToken + SHADER_UNIFORMS_REPLACE_TOKEN_LENGTH) + 1); + memcpy(foundUniformsToken, uniformsSource, uniformsReplaceLength); + SKA_MEM_FREE(uniformsSource); + } + // Vertex functions + char* foundFunctionsToken = strstr(fullShaderBuffer, SHADER_FUNCTIONS_REPLACE_TOKEN); + if (!foundFunctionsToken) { + SHADER_FILE_PARSER_ERROR_RETURN(result, originalSource, "Unable to find functions token in vertex shader!"); + } + char* functionsSource = shader_file_parse_data_get_full_functions_source(&result.parseData); + if (functionsSource) { + const usize functionsReplaceLength = strlen(functionsSource); + memmove(foundFunctionsToken + functionsReplaceLength, + foundFunctionsToken + SHADER_FUNCTIONS_REPLACE_TOKEN_LENGTH, + strlen(foundFunctionsToken + SHADER_FUNCTIONS_REPLACE_TOKEN_LENGTH) + 1); + memcpy(foundFunctionsToken, functionsSource, functionsReplaceLength); + SKA_MEM_FREE(functionsSource); + } + // Vertex body + char* foundVertexToken = strstr(fullShaderBuffer, SHADER_VERTEX_BODY_REPLACE_TOKEN); + if (!foundVertexToken) { + SHADER_FILE_PARSER_ERROR_RETURN(result, originalSource, "Unable to find vertex() token in vertex shader!") + } + const usize vertexBodyReplaceLength = strlen(result.parseData.vertexFunctionSource); + memmove(foundVertexToken + vertexBodyReplaceLength, + foundVertexToken + SHADER_VERTEX_BODY_REPLACE_TOKEN_LENGTH, + strlen(foundVertexToken + SHADER_VERTEX_BODY_REPLACE_TOKEN_LENGTH) + 1); + memcpy(foundVertexToken, result.parseData.vertexFunctionSource, vertexBodyReplaceLength); + } +// printf("FULL VERTEX SOURCE = \n%s\n", fullShaderBuffer); + result.parseData.fullVertexSource = ska_strdup(fullShaderBuffer); + + // Create fragment source + ska_strcpy(fullShaderBuffer, shaderBaseText.fragment); + if (result.parseData.fragmentFunctionSource) { + // Fragment uniforms + char* foundUniformsToken = strstr(fullShaderBuffer, SHADER_UNIFORMS_REPLACE_TOKEN); + if (!foundUniformsToken) { + SHADER_FILE_PARSER_ERROR_RETURN(result, originalSource, "Unable to find uniforms token in fragment shader!") + } + char* uniformsSource = shader_file_parse_data_get_full_uniforms_source(&result.parseData); + if (uniformsSource) { + const usize uniformsReplaceLength = strlen(uniformsSource); + memmove(foundUniformsToken + uniformsReplaceLength, + foundUniformsToken + SHADER_UNIFORMS_REPLACE_TOKEN_LENGTH, + strlen(foundUniformsToken + SHADER_UNIFORMS_REPLACE_TOKEN_LENGTH) + 1); + memcpy(foundUniformsToken, uniformsSource, uniformsReplaceLength); + SKA_MEM_FREE(uniformsSource); + } + // Fragment functions + char* foundFunctionsToken = strstr(fullShaderBuffer, SHADER_FUNCTIONS_REPLACE_TOKEN); + if (!foundFunctionsToken) { + SHADER_FILE_PARSER_ERROR_RETURN(result, originalSource, "Unable to find functions token in fragment shader!") + } + char* functionsSource = shader_file_parse_data_get_full_functions_source(&result.parseData); + if (functionsSource) { + const usize functionsReplaceLength = strlen(functionsSource); + memmove(foundFunctionsToken + functionsReplaceLength, + foundFunctionsToken + SHADER_FUNCTIONS_REPLACE_TOKEN_LENGTH, + strlen(foundFunctionsToken + SHADER_FUNCTIONS_REPLACE_TOKEN_LENGTH) + 1); + memcpy(foundFunctionsToken, functionsSource, functionsReplaceLength); + SKA_MEM_FREE(functionsSource); + } + // Fragment body + char* foundFragmentToken = strstr(fullShaderBuffer, SHADER_FRAGMENT_BODY_REPLACE_TOKEN); + if (!foundFragmentToken) { + SHADER_FILE_PARSER_ERROR_RETURN(result, originalSource, "Unable to find fragment() token in fragment shader!") + } + const usize fragmentBodyReplaceLength = strlen(result.parseData.fragmentFunctionSource); + memmove(foundFragmentToken + fragmentBodyReplaceLength, + foundFragmentToken + SHADER_FRAGMENT_BODY_REPLACE_TOKEN_LENGTH, + strlen(foundFragmentToken + SHADER_FRAGMENT_BODY_REPLACE_TOKEN_LENGTH) + 1); + memcpy(foundFragmentToken, result.parseData.fragmentFunctionSource, fragmentBodyReplaceLength); + } +// printf("FULL FRAGMENT SOURCE = \n%s\n", fullShaderBuffer); + result.parseData.fullFragmentSource = ska_strdup(fullShaderBuffer); + + SKA_MEM_FREE(originalSource); + + return result; +} + +void ska_shader_file_parse_clear_parse_result(SkaShaderFileParseResult* result) { + if (result->parseData.fragmentFunctionSource) { + SKA_MEM_FREE(result->parseData.fragmentFunctionSource); + } + if (result->parseData.vertexFunctionSource) { + SKA_MEM_FREE(result->parseData.vertexFunctionSource); + } + if (result->parseData.fullVertexSource) { + SKA_MEM_FREE(result->parseData.fullVertexSource); + } + if (result->parseData.fullFragmentSource) { + SKA_MEM_FREE(result->parseData.fullFragmentSource); + } + for (usize i = 0; i < result->parseData.uniformCount; i++) { + SKA_MEM_FREE(result->parseData.uniforms[i].name); + } + for (usize i = 0; i < result->parseData.functionCount; i++) { + SKA_MEM_FREE(result->parseData.functions[i].name); + SKA_MEM_FREE(result->parseData.functions[i].fullFunctionSource); + } +} + +#endif // #if SKA_RENDERING diff --git a/seika/rendering/shader/shader_file_parser.h b/seika/rendering/shader/shader_file_parser.h new file mode 100644 index 0000000..b2e3718 --- /dev/null +++ b/seika/rendering/shader/shader_file_parser.h @@ -0,0 +1,32 @@ +#pragma once + +#if SKA_RENDERING + +#include "shader_instance.h" + +typedef struct SkaShaderFileParserFunction { + char* name; + char* fullFunctionSource; +} SkaShaderFileParserFunction; + +typedef struct SkaShaderFileParseData { + SkaShaderInstanceType shaderType; + char* fullVertexSource; + char* fullFragmentSource; + char* vertexFunctionSource; + char* fragmentFunctionSource; + usize uniformCount; + usize functionCount; + SkaShaderParam uniforms[32]; + SkaShaderFileParserFunction functions[32]; +} SkaShaderFileParseData; + +typedef struct SkaShaderFileParseResult { + char errorMessage[128]; + SkaShaderFileParseData parseData; +} SkaShaderFileParseResult; + +SkaShaderFileParseResult ska_shader_file_parser_parse_shader(const char* shaderSource); +void ska_shader_file_parse_clear_parse_result(SkaShaderFileParseResult* result); + +#endif // #if SKA_RENDERING diff --git a/seika/rendering/shader/shader_instance.c b/seika/rendering/shader/shader_instance.c new file mode 100644 index 0000000..c072b73 --- /dev/null +++ b/seika/rendering/shader/shader_instance.c @@ -0,0 +1,201 @@ +#if SKA_RENDERING + +#include "shader_instance.h" + +#include +#include + +#include "seika/memory.h" +#include "seika/logger.h" +#include "seika/string.h" +#include "seika/assert.h" + +SkaShaderInstance* ska_shader_instance_create(const char* vertexSource, const char* fragmentSource) { + SkaShader* shader = ska_shader_compile_new_shader(vertexSource, fragmentSource); + // Early out if shader fails to compile + if (shader == NULL) { + return NULL; + } + SkaShaderInstance* instance = SKA_MEM_ALLOCATE(SkaShaderInstance); + instance->shader = shader; + instance->paramMap = ska_string_hash_map_create_default_capacity(); + instance->paramsDirty = true; + return instance; +} + +SkaShaderInstance* ska_shader_instance_create_from_shader(SkaShader* shader) { + SKA_ASSERT(shader != NULL); + SkaShaderInstance* instance = SKA_MEM_ALLOCATE(SkaShaderInstance); + instance->shader = shader; + instance->paramMap = ska_string_hash_map_create_default_capacity(); + instance->paramsDirty = true; + return instance; +} + +void ska_shader_instance_destroy(SkaShaderInstance* shaderInstance) { + SKA_STRING_HASH_MAP_FOR_EACH(shaderInstance->paramMap, iter) { + SkaStringHashMapNode* node = iter.pair; + SkaShaderParam* param = (SkaShaderParam*)node->value; + SKA_MEM_FREE(param->name); + } + ska_string_hash_map_destroy(shaderInstance->paramMap); + ska_shader_destroy(shaderInstance->shader); + SKA_MEM_FREE(shaderInstance); +} + +// Creation functions +void ska_shader_instance_param_create_from_copy(SkaShaderInstance* shaderInstance, SkaShaderParam* param) { + param->name = ska_strdup(param->name); + switch (param->type) { + case SkaShaderParamType_BOOL: { + ska_shader_instance_param_create_bool(shaderInstance, param->name, param->value.boolValue); + return; + } + case SkaShaderParamType_INT: { + ska_shader_instance_param_create_int(shaderInstance, param->name, param->value.intValue); + return; + } + case SkaShaderParamType_FLOAT: { + ska_shader_instance_param_create_float(shaderInstance, param->name, param->value.floatValue); + return; + } + case SkaShaderParamType_FLOAT2: { + ska_shader_instance_param_create_float2(shaderInstance, param->name, param->value.float2Value); + return; + } + case SkaShaderParamType_FLOAT3: { + ska_shader_instance_param_create_float3(shaderInstance, param->name, param->value.float3Value); + return; + } + case SkaShaderParamType_FLOAT4: { + ska_shader_instance_param_create_float4(shaderInstance, param->name, param->value.float4Value); + return; + } + } + SKA_ASSERT_FMT(false, "Failed to copy shader param with name '%s'", param->name); +} + +SkaShaderParam* ska_shader_instance_param_create_bool(SkaShaderInstance* shaderInstance, const char* name, bool value) { + SkaShaderParam params = { .name = ska_strdup(name), .type = SkaShaderParamType_BOOL }; + params.value.boolValue = value; + ska_string_hash_map_add(shaderInstance->paramMap, name, ¶ms, sizeof(SkaShaderParam)); + return (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); +} + +SkaShaderParam* ska_shader_instance_param_create_int(SkaShaderInstance* shaderInstance, const char* name, int32 value) { + SkaShaderParam params = { .name = ska_strdup(name), .type = SkaShaderParamType_INT }; + params.value.intValue = value; + ska_string_hash_map_add(shaderInstance->paramMap, name, ¶ms, sizeof(SkaShaderParam)); + return (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); +} + +SkaShaderParam* ska_shader_instance_param_create_float(SkaShaderInstance* shaderInstance, const char* name, f32 value) { + SkaShaderParam params = { .name = ska_strdup(name), .type = SkaShaderParamType_FLOAT }; + params.value.floatValue = value; + ska_string_hash_map_add(shaderInstance->paramMap, name, ¶ms, sizeof(SkaShaderParam)); + return (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); +} + +SkaShaderParam* ska_shader_instance_param_create_float2(SkaShaderInstance* shaderInstance, const char* name, SkaVector2 value) { + SkaShaderParam params = { .name = ska_strdup(name), .type = SkaShaderParamType_FLOAT2 }; + params.value.float2Value = value; + ska_string_hash_map_add(shaderInstance->paramMap, name, ¶ms, sizeof(SkaShaderParam)); + return (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); +} + +SkaShaderParam* ska_shader_instance_param_create_float3(SkaShaderInstance* shaderInstance, const char* name, SkaVector3 value) { + SkaShaderParam params = { .name = ska_strdup(name), .type = SkaShaderParamType_FLOAT3 }; + params.value.float3Value = value; + ska_string_hash_map_add(shaderInstance->paramMap, name, ¶ms, sizeof(SkaShaderParam)); + return (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); +} + +SkaShaderParam* ska_shader_instance_param_create_float4(SkaShaderInstance* shaderInstance, const char* name, SkaVector4 value) { + SkaShaderParam params = { .name = ska_strdup(name), .type = SkaShaderParamType_FLOAT4 }; + params.value.float4Value = value; + ska_string_hash_map_add(shaderInstance->paramMap, name, ¶ms, sizeof(SkaShaderParam)); + return (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); +} + +// Update functions +void ska_shader_instance_param_update_bool(SkaShaderInstance* shaderInstance, const char* name, bool value) { + SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); + SKA_ASSERT(param->type == SkaShaderParamType_BOOL); + param->value.boolValue = value; + shaderInstance->paramsDirty = true; +} + +void ska_shader_instance_param_update_int(SkaShaderInstance* shaderInstance, const char* name, int32 value) { + SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); + SKA_ASSERT(param->type == SkaShaderParamType_INT); + param->value.intValue = value; + shaderInstance->paramsDirty = true; +} + +void ska_shader_instance_param_update_float(SkaShaderInstance* shaderInstance, const char* name, f32 value) { + SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); + SKA_ASSERT_FMT(param != NULL, "Shader param for '%s' is null!", name); + SKA_ASSERT(param->type == SkaShaderParamType_FLOAT); + param->value.floatValue = value; + shaderInstance->paramsDirty = true; +} + +void ska_shader_instance_param_update_float2(SkaShaderInstance* shaderInstance, const char* name, SkaVector2 value) { + SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); + SKA_ASSERT(param->type == SkaShaderParamType_FLOAT2); + param->value.float2Value = value; + shaderInstance->paramsDirty = true; +} + +void ska_shader_instance_param_update_float3(SkaShaderInstance* shaderInstance, const char* name, SkaVector3 value) { + SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); + SKA_ASSERT(param->type == SkaShaderParamType_FLOAT3); + param->value.float3Value = value; + shaderInstance->paramsDirty = true; +} + +void ska_shader_instance_param_update_float4(SkaShaderInstance* shaderInstance, const char* name, SkaVector4 value) { + SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); + SKA_ASSERT(param->type == SkaShaderParamType_FLOAT4); + param->value.float4Value = value; + shaderInstance->paramsDirty = true; +} + +// Get functions +bool ska_shader_instance_param_get_bool(SkaShaderInstance* shaderInstance, const char* name) { + SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); + SKA_ASSERT(param->type == SkaShaderParamType_BOOL); + return param->value.boolValue; +} + +int32 ska_shader_instance_param_get_int(SkaShaderInstance* shaderInstance, const char* name) { + SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); + SKA_ASSERT(param->type == SkaShaderParamType_INT); + return param->value.intValue; +} + +f32 ska_shader_instance_param_get_float(SkaShaderInstance* shaderInstance, const char* name) { + SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); + SKA_ASSERT(param->type == SkaShaderParamType_FLOAT); + return param->value.floatValue; +} + +SkaVector2 ska_shader_instance_param_get_float2(SkaShaderInstance* shaderInstance, const char* name) { + SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); + SKA_ASSERT(param->type == SkaShaderParamType_FLOAT2); + return param->value.float2Value; +} + +SkaVector3 ska_shader_instance_param_get_float3(SkaShaderInstance* shaderInstance, const char* name) { + SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); + SKA_ASSERT(param->type == SkaShaderParamType_FLOAT3); + return param->value.float3Value; +} + +SkaVector4 ska_shader_instance_param_get_float4(SkaShaderInstance* shaderInstance, const char* name) { + SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); + SKA_ASSERT(param->type == SkaShaderParamType_FLOAT4); + return param->value.float4Value; +} + +#endif // #if SKA_RENDERING diff --git a/seika/rendering/shader/shader_instance.h b/seika/rendering/shader/shader_instance.h new file mode 100644 index 0000000..6ed2da8 --- /dev/null +++ b/seika/rendering/shader/shader_instance.h @@ -0,0 +1,76 @@ +#pragma once + +#if SKA_RENDERING + +/* + * Shader Instance + * --------------------------------------------------------------------------------------------------------------------- + * A work in progress api to create shader instances with parameters. + */ + +#include "shader.h" +#include "seika/data_structures/hash_map_string.h" + +// Shader Param - Shader instance representation of uniform parameters +typedef enum SkaShaderParamType { + SkaShaderParamType_BOOL = 0, + SkaShaderParamType_INT = 1, + SkaShaderParamType_FLOAT = 2, + SkaShaderParamType_FLOAT2 = 3, + SkaShaderParamType_FLOAT3 = 4, + SkaShaderParamType_FLOAT4 = 5, +} SkaShaderParamType; + +typedef struct SkaShaderParam { + char* name; + SkaShaderParamType type; + union { + bool boolValue; + int32 intValue; + f32 floatValue; + SkaVector2 float2Value; + SkaVector3 float3Value; + SkaVector4 float4Value; + } value; +} SkaShaderParam; + +// Shader Instance +typedef enum SkaShaderInstanceType { + SkaShaderInstanceType_INVALID = -1, + SkaShaderInstanceType_SCREEN = 0, + SkaShaderInstanceType_SPRITE = 1, +} SkaShaderInstanceType; + +typedef struct SkaShaderInstance { + SkaShader* shader; + SkaStringHashMap* paramMap; + bool paramsDirty; +} SkaShaderInstance; + +SkaShaderInstance* ska_shader_instance_create(const char* vertexSource, const char* fragmentSource); +SkaShaderInstance* ska_shader_instance_create_from_shader(SkaShader* shader); +void ska_shader_instance_destroy(SkaShaderInstance* shaderInstance); + +void ska_shader_instance_param_create_from_copy(SkaShaderInstance* shaderInstance, SkaShaderParam* param); +SkaShaderParam* ska_shader_instance_param_create_bool(SkaShaderInstance* shaderInstance, const char* name, bool value); +SkaShaderParam* ska_shader_instance_param_create_int(SkaShaderInstance* shaderInstance, const char* name, int32 value); +SkaShaderParam* ska_shader_instance_param_create_float(SkaShaderInstance* shaderInstance, const char* name, f32 value); +SkaShaderParam* ska_shader_instance_param_create_float2(SkaShaderInstance* shaderInstance, const char* name, SkaVector2 value); +SkaShaderParam* ska_shader_instance_param_create_float3(SkaShaderInstance* shaderInstance, const char* name, SkaVector3 value); +SkaShaderParam* ska_shader_instance_param_create_float4(SkaShaderInstance* shaderInstance, const char* name, SkaVector4 value); + +void ska_shader_instance_param_update_bool(SkaShaderInstance* shaderInstance, const char* name, bool value); +void ska_shader_instance_param_update_int(SkaShaderInstance* shaderInstance, const char* name, int32 value); +void ska_shader_instance_param_update_float(SkaShaderInstance* shaderInstance, const char* name, f32 value); +void ska_shader_instance_param_update_float2(SkaShaderInstance* shaderInstance, const char* name, SkaVector2 value); +void ska_shader_instance_param_update_float3(SkaShaderInstance* shaderInstance, const char* name, SkaVector3 value); +void ska_shader_instance_param_update_float4(SkaShaderInstance* shaderInstance, const char* name, SkaVector4 value); + +bool ska_shader_instance_param_get_bool(SkaShaderInstance* shaderInstance, const char* name); +int32 ska_shader_instance_param_get_int(SkaShaderInstance* shaderInstance, const char* name); +f32 ska_shader_instance_param_get_float(SkaShaderInstance* shaderInstance, const char* name); +SkaVector2 ska_shader_instance_param_get_float2(SkaShaderInstance* shaderInstance, const char* name); +SkaVector3 ska_shader_instance_param_get_float3(SkaShaderInstance* shaderInstance, const char* name); +SkaVector4 ska_shader_instance_param_get_float4(SkaShaderInstance* shaderInstance, const char* name); + +#endif // #if SKA_RENDERING diff --git a/seika/rendering/shader/shader_instance_minimal.h b/seika/rendering/shader/shader_instance_minimal.h new file mode 100644 index 0000000..a2c6cec --- /dev/null +++ b/seika/rendering/shader/shader_instance_minimal.h @@ -0,0 +1,12 @@ +#pragma once + +#if SKA_RENDERING + +#include "seika/defines.h" + +#define SKA_SHADER_INSTANCE_MAX_INSTANCES 100 +#define SKA_SHADER_INSTANCE_INVALID_ID (SKA_SHADER_INSTANCE_MAX_INSTANCES + 1) + +typedef uint32 SkaShaderInstanceId; + +#endif // #if SKA_RENDERING diff --git a/seika/rendering/shader/shader_source.h b/seika/rendering/shader/shader_source.h new file mode 100644 index 0000000..545aeab --- /dev/null +++ b/seika/rendering/shader/shader_source.h @@ -0,0 +1,133 @@ +#pragma once + +#if SKA_RENDERING + +static const char* SKA_OPENGL_SHADER_SOURCE_VERTEX_SPRITE = + "#version 330 core\n" + "\n" + "layout (location = 0) in float ID;\n" + "layout (location = 1) in vec2 CRE_VERTEX;\n" + "layout (location = 2) in vec2 CRE_TEXTURE_COORDS;\n" + "layout (location = 3) in vec4 CRE_TEXTURE_MODULATE;\n" + "layout (location = 4) in float CRE_APPLY_NEAREST_NEIGHBOR;\n" + "\n" + "out vec2 UV;\n" + "out vec4 TEXTURE_MODULATE;\n" + "out float USING_NEAREST_NEIGHBOR;\n" + "\n" + "uniform float TIME;\n" + "uniform sampler2D TEXTURE;\n" + "uniform mat4 CRE_MODELS[100];\n" + "uniform mat4 CRE_PROJECTION;\n" + "\n" + "//@@UNIFORMS\n" + "\n" + "//@@FUNCTIONS\n" + "\n" + "void main() {\n" + " int CRE_SPRITE_INT_ID = int(ID);\n" + " UV = CRE_TEXTURE_COORDS;\n" + " TEXTURE_MODULATE = CRE_TEXTURE_MODULATE;\n" + " USING_NEAREST_NEIGHBOR = CRE_APPLY_NEAREST_NEIGHBOR;\n" + " vec2 VERTEX = CRE_VERTEX;\n" + " //@@vertex()\n" + " gl_Position = CRE_PROJECTION * CRE_MODELS[CRE_SPRITE_INT_ID] * vec4(VERTEX, 0.0f, 1.0f);\n" + "}\n"; + +static const char* SKA_OPENGL_SHADER_SOURCE_FRAGMENT_SPRITE = + "#version 330 core\n" + "\n" + "in vec2 UV;\n" + "in vec4 TEXTURE_MODULATE;\n" + "in float USING_NEAREST_NEIGHBOR;\n" + "\n" + "out vec4 COLOR;\n" + "\n" + "uniform float TIME;\n" + "uniform sampler2D TEXTURE;\n" + "\n" + "//@@UNIFORMS\n" + "\n" + "vec2 CRE_APPLY_NEAREST_NEIGHBOR(vec2 uv, vec2 texture_size) {\n" + " vec2 pixel = uv * texture_size;\n" + " vec2 seam = floor(pixel + 0.5);\n" + " vec2 dudv = fwidth(pixel);\n" + " pixel = seam + clamp( (pixel - seam) / dudv, -0.5, 0.5);\n" + " return pixel / texture_size;\n" + "}\n" + "\n" + "//@@FUNCTIONS\n" + "\n" + "void main() {\n" + " vec2 TEXTURE_SIZE = textureSize(TEXTURE, 0);\n" + " vec2 CRE_SPRITE_UV = mix(UV, CRE_APPLY_NEAREST_NEIGHBOR(UV, TEXTURE_SIZE), USING_NEAREST_NEIGHBOR);\n" + " COLOR = TEXTURE_MODULATE * texture(TEXTURE, CRE_SPRITE_UV);\n" + " //@@fragment()\n" + "}\n"; + +static const char* SKA_OPENGL_SHADER_SOURCE_VERTEX_FONT = + "#version 330 core\n" + "layout (location = 0) in vec4 vertex; // (pos, tex)\n" + "\n" + "out vec2 texCoords;\n" + "\n" + "uniform mat4 projection;\n" + "\n" + "void main() {\n" + " gl_Position = projection * vec4(vertex.xy, 0.0f, 1.0f);\n" + " texCoords = vertex.zw;\n" + "}\n"; + +static const char* SKA_OPENGL_SHADER_SOURCE_FRAGMENT_FONT = + "#version 330 core\n" + "in vec2 texCoords;\n" + "out vec4 color;\n" + "\n" + "uniform sampler2D textValue;\n" + "uniform vec4 textColor;\n" + "\n" + "void main() {\n" + " vec4 sampled = vec4(1.0f, 1.0f, 1.0f, texture(textValue, texCoords).r);\n" + " color = textColor * sampled;\n" + "}\n"; + +static const char* SKA_OPENGL_SHADER_SOURCE_VERTEX_SCREEN = + "#version 330 core\n" + "layout (location = 0) in vec2 CRE_VERTEX;\n" + "layout (location = 1) in vec2 CRE_TEXTURE_COORDS;\n" + "\n" + "out vec2 UV;\n" + "\n" + "uniform float TIME;\n" + "uniform sampler2D TEXTURE;\n" + "\n" + "//@@UNIFORMS\n" + "\n" + "//@@FUNCTIONS\n" + "\n" + "void main() {\n" + " UV = CRE_TEXTURE_COORDS;\n" + " vec2 VERTEX = CRE_VERTEX;\n" + " //@@vertex()\n" + " gl_Position = vec4(VERTEX, 0.0f, 1.0f);\n" + "}\n"; + +static const char* SKA_OPENGL_SHADER_SOURCE_FRAGMENT_SCREEN = + "#version 330 core\n" + "out vec4 COLOR;\n" + "\n" + "in vec2 UV;\n" + "\n" + "uniform float TIME;\n" + "uniform sampler2D TEXTURE;\n" + "\n" + "//@@UNIFORMS\n" + "\n" + "//@@FUNCTIONS\n" + "\n" + "void main() {\n" + " COLOR = texture(TEXTURE, UV);\n" + " //@@fragment()\n" + "}\n"; + +#endif // #if SKA_RENDERING diff --git a/seika/rendering/texture.c b/seika/rendering/texture.c new file mode 100644 index 0000000..3b0ce49 --- /dev/null +++ b/seika/rendering/texture.c @@ -0,0 +1,156 @@ +#if SKA_RENDERING + +#include "texture.h" + +#include +#include + +#include + +#include "seika/asset/asset_file_loader.h" +#include "seika/memory.h" +#include "seika/string.h" +#include "seika/assert.h" + +static const struct SkaTexture DEFAULT_TEXTURE_REF = { + .id = 0, + .data = NULL, + .width = 0, + .height = 0, + .nrChannels = 0, + .internalFormat = GL_RGBA, + .imageFormat = GL_RGBA, + .wrapS = GL_CLAMP_TO_BORDER, + .wrapT = GL_CLAMP_TO_BORDER, + .applyNearestNeighbor = true, + .fileName = NULL +}; + +static inline bool ska_texture_is_texture_valid(const SkaTexture* texture) { + return texture != NULL; +} + +static inline SkaTexture* ska_texture_create_default_texture() { + SkaTexture* texture = SKA_MEM_ALLOCATE(SkaTexture); + memcpy(texture, &DEFAULT_TEXTURE_REF, sizeof(SkaTexture)); + return texture; +} + +static void ska_texture_generate(SkaTexture* texture); + +SkaTexture* ska_texture_create_texture(const char* filePath) { + return ska_texture_create_texture2(filePath, DEFAULT_TEXTURE_REF.wrapS, DEFAULT_TEXTURE_REF.wrapT, DEFAULT_TEXTURE_REF.applyNearestNeighbor); +} + +SkaTexture* ska_texture_create_texture2(const char* filePath, GLint wrapS, GLint wrapT, bool applyNearestNeighbor) { + SkaTexture* texture = ska_texture_create_default_texture(); + texture->fileName = ska_strdup(filePath); + texture->wrapS = wrapS; + texture->wrapT = wrapT; + texture->applyNearestNeighbor = applyNearestNeighbor; + // Load image data + SkaAssetFileImageData* fileImageData = ska_asset_file_loader_load_image_data(filePath); + SKA_ASSERT_FMT(fileImageData != NULL, "Failed to load texture image at file path '%s'", filePath); + const usize imageDataSize = strlen((char*) fileImageData->data); + texture->data = (unsigned char*) SKA_MEM_ALLOCATE_SIZE(imageDataSize); +// memcpy(texture->data, fileImageData->data, imageDataSize); + texture->data = fileImageData->data; // TODO: Fix + texture->width = fileImageData->width; + texture->height = fileImageData->height; + texture->nrChannels = fileImageData->nrChannels; + + ska_texture_generate(texture); + + ska_asset_file_loader_free_image_data(fileImageData); + + return texture; +} + +SkaTexture* ska_texture_create_texture_from_memory(const void* buffer, usize bufferSize) { + return ska_texture_create_texture_from_memory2(buffer, bufferSize, DEFAULT_TEXTURE_REF.wrapS, + DEFAULT_TEXTURE_REF.wrapT, DEFAULT_TEXTURE_REF.applyNearestNeighbor); +} + +SkaTexture* ska_texture_create_texture_from_memory2(const void* buffer, usize bufferSize, GLint wrapS, GLint wrapT, bool applyNearestNeighbor) { + SkaTexture* texture = ska_texture_create_default_texture(); + texture->wrapS = wrapS; + texture->wrapT = wrapT; + texture->applyNearestNeighbor = applyNearestNeighbor; + texture->data = (unsigned char*) SKA_MEM_ALLOCATE_SIZE(bufferSize); + unsigned char* imageData = stbi_load_from_memory((unsigned char*)buffer, (int32)bufferSize, &texture->width, &texture->height, &texture->nrChannels, 0); + SKA_ASSERT(imageData); +// memcpy(texture->data, imageData, bufferSize); + texture->data = imageData; + + ska_texture_generate(texture); + + stbi_image_free(imageData); + + return texture; +} + +SkaTexture* ska_texture_create_solid_colored_texture(GLsizei width, GLsizei height, GLuint colorValue) { + SkaTexture* texture = ska_texture_create_default_texture(); + texture->nrChannels = 4; + texture->width = width; + texture->height = height; + + const GLsizei dataSize = width * height * 4; + texture->data = (unsigned char*)SKA_MEM_ALLOCATE_SIZE(dataSize); + for (GLsizei i = 0; i < dataSize; i++) { + texture->data[i] = colorValue; + } + + ska_texture_generate(texture); + + return texture; +} + +void ska_texture_generate(SkaTexture* texture) { + // OpenGL Stuff + if (texture->nrChannels == 1) { + texture->imageFormat = GL_RED; + } else if (texture->nrChannels == 3) { + texture->imageFormat = GL_RGB; + } else if (texture->nrChannels == 4) { + texture->imageFormat = GL_RGBA; + } + + // Create texture + glGenTextures(1, &texture->id); + glBindTexture(GL_TEXTURE_2D, texture->id); + glTexImage2D(GL_TEXTURE_2D, 0, texture->internalFormat, texture->width, texture->height, 0, texture->imageFormat, GL_UNSIGNED_BYTE, texture->data); + glGenerateMipmap(GL_TEXTURE_2D); + // Wrap and filter modes + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, texture->wrapS); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, texture->wrapT); + // Defaults to bilinear interpolation + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + // Unbind texture + glBindTexture(GL_TEXTURE_2D, 0); +} + +void ska_texture_delete(SkaTexture* texture) { + SKA_MEM_FREE(texture->fileName); + SKA_MEM_FREE(texture); +} + +GLint ska_texture_wrap_string_to_int(const char* wrap) { + if (strcmp(wrap, "clamp_to_border") == 0) { + return GL_CLAMP_TO_BORDER; + } else if (strcmp(wrap, "repeat") == 0) { + return GL_REPEAT; + } + return GL_CLAMP_TO_BORDER; +} + +const char* ska_texture_get_wrap_s_string(const SkaTexture* texture) { + return texture->wrapS == GL_REPEAT ? "repeat" : "clamp_to_border"; +} + +const char* ska_texture_get_wrap_t_string(const SkaTexture* texture) { + return texture->wrapT == GL_REPEAT ? "repeat" : "clamp_to_border"; +} + +#endif // #if SKA_RENDERING diff --git a/seika/rendering/texture.h b/seika/rendering/texture.h new file mode 100644 index 0000000..f05a2e3 --- /dev/null +++ b/seika/rendering/texture.h @@ -0,0 +1,46 @@ +#pragma once + +#if SKA_RENDERING + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +#include + +#include "seika/defines.h" + +typedef struct SkaTexture { + GLuint id; + unsigned char* data; + GLsizei width; + GLsizei height; + int32 nrChannels; + // format + GLint internalFormat; + GLint imageFormat; + // configuration + GLint wrapS; + GLint wrapT; + bool applyNearestNeighbor; + char* fileName; +} SkaTexture; + +SkaTexture* ska_texture_create_texture(const char* filePath); +SkaTexture* ska_texture_create_texture2(const char* filePath, GLint wrapS, GLint wrapT, bool applyNearestNeighbor); +SkaTexture* ska_texture_create_texture_from_memory(const void* buffer, usize bufferSize); +SkaTexture* ska_texture_create_texture_from_memory2(const void* buffer, usize bufferSize, GLint wrapS, GLint wrapT, bool applyNearestNeighbor); +SkaTexture* ska_texture_create_solid_colored_texture(GLsizei width, GLsizei height, GLuint colorValue); +void ska_texture_delete(SkaTexture* texture); +GLint ska_texture_wrap_string_to_int(const char* wrap); +const char* ska_texture_get_wrap_s_string(const SkaTexture* texture); +const char* ska_texture_get_wrap_t_string(const SkaTexture* texture); + +#ifdef __cplusplus +} +#endif + +#endif // #if SKA_RENDERING From 7c51fdf639a38e2725e0337389df859d39a1dbad Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 17 Oct 2024 23:44:50 -0400 Subject: [PATCH 25/55] More. --- CMakeLists.txt | 2 +- seika/audio/audio_manager.c | 14 +++++++------- seika/file_system.c | 4 ++-- test/test1.c | 23 +++++++++++++++++++++++ 4 files changed, 33 insertions(+), 10 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 6f8d307..d241587 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -13,7 +13,7 @@ option(SEIKA_ENABLE_1 "Will build new seika lib" ON) option(SEIKA_ECS "Will enable ecs" ON) option(SEIKA_INPUT "Will enable input" ON) option(SEIKA_RENDERING "Will enable rendering" OFF) -option(SEIKA_AUDIO "Will enable audio" OFF) +option(SEIKA_AUDIO "Will enable audio" ON) add_compile_definitions(SKA_ECS=$,1,0>) add_compile_definitions(SKA_INPUT=$,1,0>) diff --git a/seika/audio/audio_manager.c b/seika/audio/audio_manager.c index 1b6bec5..33987ba 100644 --- a/seika/audio/audio_manager.c +++ b/seika/audio/audio_manager.c @@ -39,7 +39,7 @@ static SkaAudioInstances* audio_instances = NULL; // --- Audio Manager --- // bool ska_audio_manager_init(uint32 wavSampleRate) { - audio_instances = SKA_MEM_ALLOCATE(SkaAudioInstances); + audio_instances = SKA_ALLOC(SkaAudioInstances); pthread_mutex_init(&audio_mutex, NULL); ska_audio_set_wav_sample_rate(wavSampleRate); // Device @@ -53,7 +53,7 @@ bool ska_audio_manager_init(uint32 wavSampleRate) { config.sampleRate = wavSampleRate; config.dataCallback = audio_data_callback; config.pUserData = NULL; - audio_device = SKA_MEM_ALLOCATE(ma_device); + audio_device = SKA_ALLOC(ma_device); if (ma_device_init(NULL, &config, audio_device) != MA_SUCCESS) { ska_logger_error("Failed to initialize miniaudio device!"); return false; @@ -69,10 +69,10 @@ bool ska_audio_manager_init(uint32 wavSampleRate) { void ska_audio_manager_finalize() { ma_device_uninit(audio_device); - SKA_MEM_FREE(audio_device); + SKA_FREE(audio_device); audio_device = NULL; - SKA_MEM_FREE(audio_instances); // TODO: Properly free up all instances + SKA_FREE(audio_instances); // TODO: Properly free up all instances audio_instances = NULL; pthread_mutex_destroy(&audio_mutex); @@ -90,7 +90,7 @@ void ska_audio_manager_play_sound(const char* filePath, bool loops) { pthread_mutex_lock(&audio_mutex); // Create audio instance and add to instances array static unsigned int audioInstanceId = 0; // TODO: temp id for now in case we need to grab a hold of an audio instance for roll back later... - SkaAudioInstance* audioInstance = SKA_MEM_ALLOCATE(SkaAudioInstance); + SkaAudioInstance* audioInstance = SKA_ALLOC(SkaAudioInstance); audioInstance->source = ska_asset_manager_get_audio_source(filePath); audioInstance->id = audioInstanceId++; audioInstance->does_loop = loops; @@ -127,7 +127,7 @@ void audio_data_callback(ma_device* device, void* output, const void* input, ma_ SkaAudioInstance* audioInst = audio_instances->instances[i]; SKA_ASSERT_FMT(audioInst != NULL, "audio instance with index %zu is null!", i); if (!audioInst->is_playing) { - SKA_MEM_FREE(audioInst); + SKA_FREE(audioInst); audio_instances->instances[i] = NULL; removedInstances++; continue; @@ -172,7 +172,7 @@ void audio_data_callback(ma_device* device, void* output, const void* input, ma_ ska_logger_debug("Audio instance with id '%u' is queued for deletion!", audioInst->id); audio_instances->instances[i] = NULL; removedInstances++; - SKA_MEM_FREE(audioInst); + SKA_FREE(audioInst); break; } } diff --git a/seika/file_system.c b/seika/file_system.c index 2b11391..d00afff 100644 --- a/seika/file_system.c +++ b/seika/file_system.c @@ -110,7 +110,7 @@ char* ska_fs_read_file_contents(const char* filePath, usize* sz) { if (fp) { readSize = ska_fs_get_file_size(filePath); // Update buffer - buffer = (char*)SKA_MEM_ALLOCATE_SIZE(readSize + 1); + buffer = (char*)SKA_ALLOC_BYTES(readSize + 1); if (buffer != NULL) { fread(buffer, 1, readSize, fp); buffer[readSize] = '\0'; @@ -130,7 +130,7 @@ char* ska_fs_read_file_contents_without_raw(const char* filePath, usize* sz) { if (fp) { readSize = ska_fs_get_file_size(filePath); // Update buffer - buffer = (char*)SKA_MEM_ALLOCATE_SIZE(readSize + 1); + buffer = (char*)SKA_ALLOC_BYTES(readSize + 1); if (buffer != NULL) { usize bytesRead = 0; while (bytesRead < readSize) { diff --git a/test/test1.c b/test/test1.c index d0d910d..4159eeb 100644 --- a/test/test1.c +++ b/test/test1.c @@ -2,6 +2,7 @@ #include #include "seika/memory.h" +#include "seika/asset/asset_file_loader.h" #include "seika/data_structures/array_list.h" #include "seika/data_structures/id_queue.h" #include "seika/math/math.h" @@ -24,6 +25,7 @@ void tearDown(void) {} void seika_mem_test(void); void seika_array_list_test(void); void seika_id_queue_test(void); +void seika_asset_file_loader_test(void); #if SKA_ECS void seika_ecs_test(void); @@ -38,6 +40,7 @@ int32 main(int32 argv, char** args) { RUN_TEST(seika_mem_test); RUN_TEST(seika_array_list_test); RUN_TEST(seika_id_queue_test); + RUN_TEST(seika_asset_file_loader_test); #if SKA_ECS RUN_TEST(seika_ecs_test); #endif @@ -113,6 +116,26 @@ void seika_id_queue_test(void) { TEST_ASSERT_EQUAL_size_t(20, idQueue->capacity); } +void seika_asset_file_loader_test(void) { + ska_asset_file_loader_initialize(); + + ska_asset_file_loader_set_read_mode(SkaAssetFileLoaderReadMode_ARCHIVE); + const bool hasLoaded = ska_asset_file_loader_load_archive("test/resources/test.pck"); + TEST_ASSERT_TRUE(hasLoaded); + + // File exists in archive + SkaArchiveFileAsset existingFileAsset = ska_asset_file_loader_get_asset("test.txt"); + TEST_ASSERT_TRUE(ska_asset_file_loader_is_asset_valid(&existingFileAsset)); + // File doesn't exist + SkaArchiveFileAsset nonExistingFileAsset = ska_asset_file_loader_get_asset("test.png"); + TEST_ASSERT_FALSE(ska_asset_file_loader_is_asset_valid(&nonExistingFileAsset)); + // Test loading from disk + SkaArchiveFileAsset diskAsset = ska_asset_file_loader_load_asset_from_disk("test/resources/test.pck"); + TEST_ASSERT_TRUE(ska_asset_file_loader_is_asset_valid(&diskAsset)); + + ska_asset_file_loader_finalize(); +} + #if SKA_ECS typedef struct TestValueComponent { int32 value; From 753f6bdb926efb16d08d6fab38483c2b9ab89309 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 17 Oct 2024 23:52:47 -0400 Subject: [PATCH 26/55] Clean. --- CMakeLists.txt | 2 +- seika/asset/asset_file_loader.c | 2 +- seika/rendering/font.c | 6 +++--- seika/rendering/render_context.c | 4 ++-- seika/rendering/shader/shader.c | 2 +- seika/rendering/shader/shader_cache.c | 16 +++++++++------- seika/rendering/shader/shader_instance.c | 8 ++++---- seika/rendering/texture.c | 12 ++++++------ 8 files changed, 27 insertions(+), 25 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index d241587..1712977 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -12,7 +12,7 @@ option(SEIKA_ENABLE_1 "Will build new seika lib" ON) # Optional Modules option(SEIKA_ECS "Will enable ecs" ON) option(SEIKA_INPUT "Will enable input" ON) -option(SEIKA_RENDERING "Will enable rendering" OFF) +option(SEIKA_RENDERING "Will enable rendering" ON) option(SEIKA_AUDIO "Will enable audio" ON) add_compile_definitions(SKA_ECS=$,1,0>) diff --git a/seika/asset/asset_file_loader.c b/seika/asset/asset_file_loader.c index 6c78934..9ed6a42 100644 --- a/seika/asset/asset_file_loader.c +++ b/seika/asset/asset_file_loader.c @@ -129,6 +129,6 @@ SkaAssetFileImageData* ska_asset_file_loader_load_image_data(const char* filePat void ska_asset_file_loader_free_image_data(SkaAssetFileImageData* data) { stbi_image_free(data->data); - SKA_MEM_FREE(data); + SKA_FREE(data); } #endif // #if SKA_RENDERING diff --git a/seika/rendering/font.c b/seika/rendering/font.c index 3ed2a75..66c1008 100644 --- a/seika/rendering/font.c +++ b/seika/rendering/font.c @@ -15,7 +15,7 @@ static void ska_initialize_font(FT_Face face, SkaFont* font, bool applyNearestNe SkaFont* ska_font_create_font(const char* fileName, int32 size, bool applyNearestNeighbor) { FT_Face face; - SkaFont* font = SKA_MEM_ALLOCATE(SkaFont); + SkaFont* font = SKA_ALLOC(SkaFont); font->size = size; // Failed to create font, exit out early @@ -33,7 +33,7 @@ SkaFont* ska_font_create_font(const char* fileName, int32 size, bool applyNeares SkaFont* ska_font_create_font_from_memory(const void* buffer, usize bufferSize, int32 size, bool applyNearestNeighbor) { FT_Face face; - SkaFont* font = SKA_MEM_ALLOCATE(SkaFont); + SkaFont* font = SKA_ALLOC(SkaFont); font->size = size; // Failed to create font, exit out early @@ -50,7 +50,7 @@ SkaFont* ska_font_create_font_from_memory(const void* buffer, usize bufferSize, } void ska_font_delete(SkaFont* font) { - SKA_MEM_FREE(font); + SKA_FREE(font); } bool ska_generate_new_font_face(const char* fileName, FT_Face* face) { diff --git a/seika/rendering/render_context.c b/seika/rendering/render_context.c index 35de69e..3d63bd6 100644 --- a/seika/rendering/render_context.c +++ b/seika/rendering/render_context.c @@ -11,12 +11,12 @@ static SkaRenderContext* renderContext = NULL; void ska_render_context_initialize() { SKA_ASSERT_FMT(renderContext == NULL, "Render context is already initialized!"); - renderContext = SKA_MEM_ALLOCATE(SkaRenderContext); + renderContext = SKA_ALLOC(SkaRenderContext); } void ska_render_context_finalize() { SKA_ASSERT_FMT(renderContext != NULL, "Render context is not initialized!"); - SKA_MEM_FREE(renderContext); + SKA_FREE(renderContext); } SkaRenderContext* ska_render_context_get() { diff --git a/seika/rendering/shader/shader.c b/seika/rendering/shader/shader.c index a2c0dcc..24ce965 100644 --- a/seika/rendering/shader/shader.c +++ b/seika/rendering/shader/shader.c @@ -8,7 +8,7 @@ static bool shader_check_compile_errors(uint32 shaderId, const char* type); SkaShader* ska_shader_compile_new_shader(const char* vertexSource, const char* fragmentSource) { - SkaShader* shader = SKA_MEM_ALLOCATE(SkaShader); + SkaShader* shader = SKA_ALLOC(SkaShader); GLuint vertex, fragment; // vertex vertex = glCreateShader(GL_VERTEX_SHADER); diff --git a/seika/rendering/shader/shader_cache.c b/seika/rendering/shader/shader_cache.c index 951125f..8d01be8 100644 --- a/seika/rendering/shader/shader_cache.c +++ b/seika/rendering/shader/shader_cache.c @@ -8,7 +8,7 @@ #include "seika/memory.h" #include "seika/assert.h" #include "seika/asset/asset_file_loader.h" -#include "seika/data_structures/queue.h" +#include "seika/data_structures/id_queue.h" #include "seika/logger.h" // --- Parsed Shader Cache --- // @@ -20,14 +20,14 @@ SkaStringHashMap* parsedShaderCacheMap = NULL; // --- Shader Cache --- // static SkaShaderInstance* instanceCache[SKA_SHADER_INSTANCE_MAX_INSTANCES]; -static SkaQueue* shaderInstanceIdQueue = NULL; +static SkaIdQueue* shaderInstanceIdQueue = NULL; void ska_shader_cache_initialize() { SKA_ASSERT(shaderInstanceIdQueue == NULL); SKA_ASSERT(parsedShaderCacheMap == NULL); - shaderInstanceIdQueue = ska_queue_create(SKA_SHADER_INSTANCE_MAX_INSTANCES, SKA_SHADER_INSTANCE_INVALID_ID); + shaderInstanceIdQueue = ska_id_queue_create(SKA_SHADER_INSTANCE_MAX_INSTANCES); for (uint32_t i = 0; i < SKA_SHADER_INSTANCE_MAX_INSTANCES; i++) { - ska_queue_enqueue(shaderInstanceIdQueue, i); + ska_id_queue_enqueue(shaderInstanceIdQueue, i); instanceCache[i] = NULL; } parsedShaderCacheMap = ska_string_hash_map_create_default_capacity(); @@ -36,7 +36,7 @@ void ska_shader_cache_initialize() { void ska_shader_cache_finalize() { SKA_ASSERT(shaderInstanceIdQueue != NULL); SKA_ASSERT(parsedShaderCacheMap != NULL); - ska_queue_destroy(shaderInstanceIdQueue); + ska_id_queue_destroy(shaderInstanceIdQueue); shaderInstanceIdQueue = NULL; SKA_STRING_HASH_MAP_FOR_EACH(parsedShaderCacheMap, iter) { SkaStringHashMapNode* node = iter.pair; @@ -48,14 +48,16 @@ void ska_shader_cache_finalize() { } SkaShaderInstanceId ska_shader_cache_add_instance(SkaShaderInstance* instance) { - const SkaShaderInstanceId newId = ska_queue_dequeue(shaderInstanceIdQueue); + SkaShaderInstanceId newId; + const bool succes = ska_id_queue_dequeue(shaderInstanceIdQueue, &newId); + SKA_ASSERT(succes); instanceCache[newId] = instance; return newId; } void ska_shader_cache_remove_instance(SkaShaderInstanceId instanceId) { instanceCache[instanceId] = NULL; - ska_queue_enqueue(shaderInstanceIdQueue, instanceId); + ska_id_queue_enqueue(shaderInstanceIdQueue, instanceId); } SkaShaderInstance* ska_shader_cache_get_instance(SkaShaderInstanceId instanceId) { diff --git a/seika/rendering/shader/shader_instance.c b/seika/rendering/shader/shader_instance.c index c072b73..9d44a98 100644 --- a/seika/rendering/shader/shader_instance.c +++ b/seika/rendering/shader/shader_instance.c @@ -16,7 +16,7 @@ SkaShaderInstance* ska_shader_instance_create(const char* vertexSource, const ch if (shader == NULL) { return NULL; } - SkaShaderInstance* instance = SKA_MEM_ALLOCATE(SkaShaderInstance); + SkaShaderInstance* instance = SKA_ALLOC(SkaShaderInstance); instance->shader = shader; instance->paramMap = ska_string_hash_map_create_default_capacity(); instance->paramsDirty = true; @@ -25,7 +25,7 @@ SkaShaderInstance* ska_shader_instance_create(const char* vertexSource, const ch SkaShaderInstance* ska_shader_instance_create_from_shader(SkaShader* shader) { SKA_ASSERT(shader != NULL); - SkaShaderInstance* instance = SKA_MEM_ALLOCATE(SkaShaderInstance); + SkaShaderInstance* instance = SKA_ALLOC(SkaShaderInstance); instance->shader = shader; instance->paramMap = ska_string_hash_map_create_default_capacity(); instance->paramsDirty = true; @@ -36,11 +36,11 @@ void ska_shader_instance_destroy(SkaShaderInstance* shaderInstance) { SKA_STRING_HASH_MAP_FOR_EACH(shaderInstance->paramMap, iter) { SkaStringHashMapNode* node = iter.pair; SkaShaderParam* param = (SkaShaderParam*)node->value; - SKA_MEM_FREE(param->name); + SKA_FREE(param->name); } ska_string_hash_map_destroy(shaderInstance->paramMap); ska_shader_destroy(shaderInstance->shader); - SKA_MEM_FREE(shaderInstance); + SKA_FREE(shaderInstance); } // Creation functions diff --git a/seika/rendering/texture.c b/seika/rendering/texture.c index 3b0ce49..b57a275 100644 --- a/seika/rendering/texture.c +++ b/seika/rendering/texture.c @@ -31,7 +31,7 @@ static inline bool ska_texture_is_texture_valid(const SkaTexture* texture) { } static inline SkaTexture* ska_texture_create_default_texture() { - SkaTexture* texture = SKA_MEM_ALLOCATE(SkaTexture); + SkaTexture* texture = SKA_ALLOC(SkaTexture); memcpy(texture, &DEFAULT_TEXTURE_REF, sizeof(SkaTexture)); return texture; } @@ -52,7 +52,7 @@ SkaTexture* ska_texture_create_texture2(const char* filePath, GLint wrapS, GLint SkaAssetFileImageData* fileImageData = ska_asset_file_loader_load_image_data(filePath); SKA_ASSERT_FMT(fileImageData != NULL, "Failed to load texture image at file path '%s'", filePath); const usize imageDataSize = strlen((char*) fileImageData->data); - texture->data = (unsigned char*) SKA_MEM_ALLOCATE_SIZE(imageDataSize); + texture->data = (unsigned char*) SKA_ALLOC_BYTES(imageDataSize); // memcpy(texture->data, fileImageData->data, imageDataSize); texture->data = fileImageData->data; // TODO: Fix texture->width = fileImageData->width; @@ -76,7 +76,7 @@ SkaTexture* ska_texture_create_texture_from_memory2(const void* buffer, usize bu texture->wrapS = wrapS; texture->wrapT = wrapT; texture->applyNearestNeighbor = applyNearestNeighbor; - texture->data = (unsigned char*) SKA_MEM_ALLOCATE_SIZE(bufferSize); + texture->data = (unsigned char*) SKA_ALLOC_BYTES(bufferSize); unsigned char* imageData = stbi_load_from_memory((unsigned char*)buffer, (int32)bufferSize, &texture->width, &texture->height, &texture->nrChannels, 0); SKA_ASSERT(imageData); // memcpy(texture->data, imageData, bufferSize); @@ -96,7 +96,7 @@ SkaTexture* ska_texture_create_solid_colored_texture(GLsizei width, GLsizei heig texture->height = height; const GLsizei dataSize = width * height * 4; - texture->data = (unsigned char*)SKA_MEM_ALLOCATE_SIZE(dataSize); + texture->data = (unsigned char*)SKA_ALLOC_BYTES(dataSize); for (GLsizei i = 0; i < dataSize; i++) { texture->data[i] = colorValue; } @@ -132,8 +132,8 @@ void ska_texture_generate(SkaTexture* texture) { } void ska_texture_delete(SkaTexture* texture) { - SKA_MEM_FREE(texture->fileName); - SKA_MEM_FREE(texture); + SKA_FREE(texture->fileName); + SKA_FREE(texture); } GLint ska_texture_wrap_string_to_int(const char* wrap) { From 83b16c07eee106e481b424ea3ef350bf6e154b8a Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 17 Oct 2024 23:58:48 -0400 Subject: [PATCH 27/55] More tests. --- seika/data_structures/array2d.c | 4 +- test/test1.c | 132 ++++++++++++++++++++++++++++++++ 2 files changed, 134 insertions(+), 2 deletions(-) diff --git a/seika/data_structures/array2d.c b/seika/data_structures/array2d.c index a2d6dec..f6baec1 100644 --- a/seika/data_structures/array2d.c +++ b/seika/data_structures/array2d.c @@ -9,9 +9,9 @@ SkaArray2D* ska_array2d_create(usize rows, usize cols, usize elementSize) { SkaArray2D* newArray = SKA_ALLOC(SkaArray2D); - newArray->data = SKA_ALLOC_BYTES(cols * sizeof(void*)); + newArray->data = SKA_ALLOC_BYTES_ZEROED(cols * sizeof(void*)); for (usize i = 0; i < cols; i++) { - newArray->data[i] = SKA_ALLOC_BYTES(rows * elementSize); + newArray->data[i] = SKA_ALLOC_BYTES_ZEROED(rows * elementSize); } newArray->size = (SkaSize2Di){ .w = (int32)rows, .h = (int32)cols }; newArray->elementSize = elementSize; diff --git a/test/test1.c b/test/test1.c index 4159eeb..f8546e0 100644 --- a/test/test1.c +++ b/test/test1.c @@ -3,8 +3,10 @@ #include "seika/memory.h" #include "seika/asset/asset_file_loader.h" +#include "seika/data_structures/array2d.h" #include "seika/data_structures/array_list.h" #include "seika/data_structures/id_queue.h" +#include "seika/data_structures/spatial_hash_map.h" #include "seika/math/math.h" #if SKA_ECS @@ -24,6 +26,9 @@ void tearDown(void) {} void seika_mem_test(void); void seika_array_list_test(void); +void seika_hash_map_test(void); +void seika_spatial_hash_map_test(void); +void seika_array2d_test(void); void seika_id_queue_test(void); void seika_asset_file_loader_test(void); @@ -39,6 +44,9 @@ int32 main(int32 argv, char** args) { UNITY_BEGIN(); RUN_TEST(seika_mem_test); RUN_TEST(seika_array_list_test); + RUN_TEST(seika_hash_map_test); + RUN_TEST(seika_spatial_hash_map_test); + RUN_TEST(seika_array2d_test); RUN_TEST(seika_id_queue_test); RUN_TEST(seika_asset_file_loader_test); #if SKA_ECS @@ -116,6 +124,130 @@ void seika_id_queue_test(void) { TEST_ASSERT_EQUAL_size_t(20, idQueue->capacity); } +void seika_hash_map_test(void) { + SkaHashMap* hashMap = ska_hash_map_create(sizeof(int32), sizeof(int32), SKA_HASH_MAP_MIN_CAPACITY); + TEST_ASSERT_NOT_NULL(hashMap); + + int32 key1 = 0; + int32 value1 = 11; + ska_hash_map_add(hashMap, &key1, &value1); + TEST_ASSERT_EQUAL_INT(1, hashMap->size); + int32 returnedValue1 = *(int32*) ska_hash_map_get(hashMap, &key1); + TEST_ASSERT_EQUAL_INT(value1, returnedValue1); + + int32 key2 = 1; + int32 value2 = 22; + ska_hash_map_add(hashMap, &key2, &value2); + TEST_ASSERT_EQUAL_INT(2, hashMap->size); + + // Iterator test + int32 iterCount = 0; + for (SkaHashMapIterator iterator = ska_hash_map_iter_create(hashMap); ska_hash_map_iter_is_valid(hashMap, &iterator); ska_hash_map_iter_advance(hashMap, &iterator)) { + iterCount++; + } + TEST_ASSERT_EQUAL_INT(2, iterCount); + // Iter Macro test + iterCount = 0; + SKA_HASH_MAP_FOR_EACH(hashMap, iter) { + iterCount++; + } + TEST_ASSERT_EQUAL_INT(2, iterCount); + + ska_hash_map_destroy(hashMap); +} + +void seika_spatial_hash_map_test(void) { + const int32 maxSpriteSize = 32; + SkaSpatialHashMap* spatialHashMap = ska_spatial_hash_map_create(maxSpriteSize * 2); + TEST_ASSERT_NOT_NULL(spatialHashMap); + + // Create two entities and insert them into hash map + const uint32 entity = 1; + SkaSpatialHashMapGridSpacesHandle* handle = ska_spatial_hash_map_insert_or_update(spatialHashMap, entity, &(SkaRect2) { + 0.0f, 0.0f, 32.0f, 32.0f + }); + TEST_ASSERT_EQUAL(handle, ska_spatial_hash_map_get(spatialHashMap, entity)); + + const uint32 entityTwo = 2; + SkaSpatialHashMapGridSpacesHandle* handleTwo = ska_spatial_hash_map_insert_or_update(spatialHashMap, entityTwo, &(SkaRect2) { + 16.0f, 16.0f, 48.0f, 48.0f + }); + TEST_ASSERT_EQUAL(handleTwo, ska_spatial_hash_map_get(spatialHashMap, entityTwo)); + + // An entity that should not be collided with + const uint32 entityNotCollided = 3; + ska_spatial_hash_map_insert_or_update(spatialHashMap, entityNotCollided, &(SkaRect2) { + 64.0f, 64.0f, 96.0f, 96.0f + }); + + // Test collision result to make sure the two entities collide + const SkaSpatialHashMapCollisionResult collisionResult = ska_spatial_hash_map_compute_collision(spatialHashMap, entity); + TEST_ASSERT_EQUAL_INT(1, collisionResult.collisionCount); + + if (collisionResult.collisionCount > 0) { + TEST_ASSERT_EQUAL_INT(2, collisionResult.collisions[0]); + } + + ska_spatial_hash_map_remove(spatialHashMap, entity); + TEST_ASSERT_NULL(ska_spatial_hash_map_get(spatialHashMap, entity)); + ska_spatial_hash_map_remove(spatialHashMap, entityTwo); + TEST_ASSERT_NULL(ska_spatial_hash_map_get(spatialHashMap, entityTwo)); + + ska_spatial_hash_map_destroy(spatialHashMap); +} + +void seika_array2d_test(void) { + typedef struct TestArrayStruct { + int value; + } TestArrayStruct; + + SkaArray2D* array2D = ska_array2d_create(5, 5, sizeof(TestArrayStruct)); + + TestArrayStruct* struct0_3 = (TestArrayStruct*)ska_array2d_get(array2D, 0, 3); + TEST_ASSERT_NOT_NULL(struct0_3); + TEST_ASSERT_EQUAL_INT(0, struct0_3->value); + + struct0_3->value = 5; + const TestArrayStruct* struct0_3Again = (TestArrayStruct*)ska_array2d_get(array2D, 0, 3); + TEST_ASSERT_EQUAL_INT(5, struct0_3Again->value); + + TestArrayStruct* struct4_2 = (TestArrayStruct*)ska_array2d_get(array2D, 4, 2); + TEST_ASSERT_NOT_NULL(struct4_2); + TEST_ASSERT_EQUAL_INT(0, struct4_2->value); + bool wasSetSuccessful = ska_array2d_set(array2D, 4, 2, &(TestArrayStruct){ .value = 1000 }); + TEST_ASSERT_TRUE(wasSetSuccessful); + TEST_ASSERT_EQUAL_INT(1000, struct4_2->value); + wasSetSuccessful = false; + + TestArrayStruct* struct7_9 = (TestArrayStruct*)ska_array2d_get(array2D, 7, 7); + TEST_ASSERT_NULL(struct7_9); + wasSetSuccessful = ska_array2d_set(array2D, 7, 9, &(TestArrayStruct){ .value = 1000 }); + TEST_ASSERT_FALSE(wasSetSuccessful); + ska_array2d_resize(array2D, 10, 10); + struct7_9 = (TestArrayStruct*)ska_array2d_get(array2D, 7, 7); + TEST_ASSERT_NOT_NULL(struct7_9); + // Test old struct values + const TestArrayStruct* struct0_3Again2 = (TestArrayStruct*)ska_array2d_get(array2D, 0, 3); + const TestArrayStruct* struct4_2Again = (TestArrayStruct*)ska_array2d_get(array2D, 4, 2); + TEST_ASSERT_EQUAL_INT(5, struct0_3Again2->value); + TEST_ASSERT_EQUAL_INT(1000, struct4_2Again->value); + + ska_array2d_resize(array2D, 4, 4); + TEST_ASSERT_NULL(ska_array2d_get(array2D, 7, 7)); + const TestArrayStruct* struct0_3Again3 = (TestArrayStruct*)ska_array2d_get(array2D, 0, 3); + TEST_ASSERT_NOT_NULL(struct0_3Again3); + TEST_ASSERT_EQUAL_INT(5, struct0_3Again3->value); + + ska_array2d_reset(array2D); + const TestArrayStruct* struct0_3Again4 = (TestArrayStruct*)ska_array2d_get(array2D, 0, 3); + TEST_ASSERT_EQUAL_INT(0, struct0_3Again4->value); + ska_array2d_reset_default(array2D, &(TestArrayStruct){ .value = 230 }); + const TestArrayStruct* struct0_3Again5 = (TestArrayStruct*)ska_array2d_get(array2D, 0, 3); + TEST_ASSERT_EQUAL_INT(230, struct0_3Again5->value); + + ska_array2d_destroy(array2D); +} + void seika_asset_file_loader_test(void) { ska_asset_file_loader_initialize(); From 4b24f86a638c5a35dddebce2182b45a8cc1eccad Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Fri, 18 Oct 2024 00:03:39 -0400 Subject: [PATCH 28/55] Updates. --- CMakeLists.txt | 22 +- seika/CMakeLists.txt | 2 +- test/{test1.c => old_test.c} | 459 +++++++++++++++++++++-------------- test/test.c | 459 ++++++++++++++--------------------- 4 files changed, 464 insertions(+), 478 deletions(-) rename test/{test1.c => old_test.c} (71%) diff --git a/CMakeLists.txt b/CMakeLists.txt index 1712977..b79e997 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,8 +6,6 @@ project(seika-framework C) option(IS_CI_BUILD "" OFF) option(SEIKA_STATIC_LIB "Make seika and dependent libs static" OFF) -option(SEIKA_ENABLE_OLD "Will build old seika lib" OFF) -option(SEIKA_ENABLE_1 "Will build new seika lib" ON) # Optional Modules option(SEIKA_ECS "Will enable ecs" ON) @@ -26,12 +24,7 @@ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) #--- Dependencies ---# include(Dependencies.cmake) -if (SEIKA_ENABLE_OLD) - add_subdirectory(old_seika) -endif() -if (SEIKA_ENABLE_1) - add_subdirectory(seika) -endif() +add_subdirectory(seika) if ("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}") set(SK_IS_MAIN TRUE) @@ -40,14 +33,7 @@ else() endif() if (SK_IS_MAIN) - if (SEIKA_ENABLE_OLD) - # Create old_seika test exe - add_executable(seika_test test/test.c) - target_link_libraries(seika_test seika unity) - endif() - if (SEIKA_ENABLE_1) - # Create seika1 test exe - add_executable(seika1_test test/test1.c) - target_link_libraries(seika1_test seika1 unity) - endif() + # Create seika test exe + add_executable(seika_test test/test.c) + target_link_libraries(seika_test seika unity) endif() diff --git a/seika/CMakeLists.txt b/seika/CMakeLists.txt index 179c481..3dab300 100644 --- a/seika/CMakeLists.txt +++ b/seika/CMakeLists.txt @@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.27.0) set(CMAKE_C_STANDARD 11) -project(seika1 C) +project(seika C) if (CMAKE_C_COMPILER_ID STREQUAL "MSVC") list(APPEND flags "/W3" "/Zc:preprocessor") diff --git a/test/test1.c b/test/old_test.c similarity index 71% rename from test/test1.c rename to test/old_test.c index f8546e0..2d09753 100644 --- a/test/test1.c +++ b/test/old_test.c @@ -2,21 +2,18 @@ #include #include "seika/memory.h" -#include "seika/asset/asset_file_loader.h" -#include "seika/data_structures/array2d.h" -#include "seika/data_structures/array_list.h" -#include "seika/data_structures/id_queue.h" +#include "seika/event.h" +#include "seika/input/input.h" +#include "seika/data_structures/hash_map.h" #include "seika/data_structures/spatial_hash_map.h" -#include "seika/math/math.h" - -#if SKA_ECS -#include "seika/ecs/ecs.h" +#include "seika/data_structures/array2d.h" +#include "seika/data_structures/linked_list.h" #include "seika/ecs/ec_system.h" -#endif - -#if SKA_INPUT -#include "seika/input/input.h" -#endif +#include "seika/ecs/ecs.h" +#include "seika/math/curve_float.h" +#include "seika/asset/asset_file_loader.h" +#include "seika/rendering/shader/shader_instance.h" +#include "seika/rendering/shader/shader_file_parser.h" #define RESOURCES_PATH "test/resources" #define RESOURCES_PACK_PATH "test/resources/test.pck" @@ -24,104 +21,118 @@ void setUp(void) {} void tearDown(void) {} -void seika_mem_test(void); -void seika_array_list_test(void); +void seika_input_test(void); void seika_hash_map_test(void); void seika_spatial_hash_map_test(void); +void seika_linked_list_test(void); void seika_array2d_test(void); -void seika_id_queue_test(void); -void seika_asset_file_loader_test(void); -#if SKA_ECS +void seika_asset_file_loader_test(void); +void seika_observer_test(void); +void seika_curve_float_test(void); +void seika_shader_instance_test(void); +void seika_shader_file_parser_test(void); void seika_ecs_test(void); -#endif - -#if SKA_INPUT -void seika_input_test(void); -#endif int32 main(int32 argv, char** args) { UNITY_BEGIN(); - RUN_TEST(seika_mem_test); - RUN_TEST(seika_array_list_test); + RUN_TEST(seika_input_test); RUN_TEST(seika_hash_map_test); RUN_TEST(seika_spatial_hash_map_test); + RUN_TEST(seika_linked_list_test); RUN_TEST(seika_array2d_test); - RUN_TEST(seika_id_queue_test); RUN_TEST(seika_asset_file_loader_test); -#if SKA_ECS + RUN_TEST(seika_observer_test); + RUN_TEST(seika_curve_float_test); + RUN_TEST(seika_shader_instance_test); + RUN_TEST(seika_shader_file_parser_test); RUN_TEST(seika_ecs_test); -#endif -#if SKA_INPUT - RUN_TEST(seika_input_test); -#endif return UNITY_END(); } -void seika_mem_test(void) { - int* testInt = SKA_ALLOC(int); - TEST_ASSERT_NOT_NULL(testInt); - *testInt = 5; - TEST_ASSERT_EQUAL_INT(5, *testInt); - TEST_ASSERT_TRUE(ska_mem_report_leaks()); - SKA_FREE(testInt); - TEST_ASSERT_FALSE(ska_mem_report_leaks()); -} - -void seika_array_list_test(void) { - int listValues[] = { 8, 2, 3, 5 }; - SkaArrayList* arrayList = ska_array_list_create_default_capacity(sizeof(int)); - TEST_ASSERT_TRUE(ska_array_list_is_empty(arrayList)); - - for (int i = 0; i < 4; i++) { - ska_array_list_push_back(arrayList, &listValues[i]); +void seika_input_test(void) { + TEST_MESSAGE("Testing 'for each' and checking input type"); + SKA_INPUT_KEY_GAMEPAD_FOR_EACH(key) { + TEST_ASSERT_TRUE(ska_input_is_gamepad_key(key)); } - TEST_ASSERT_FALSE(ska_array_list_is_empty(arrayList)); - int index = 0; - SKA_ARRAY_LIST_FOR_EACH(arrayList, int, i) { - const int value = (int)*(int*)ska_array_list_get(arrayList, index); - TEST_ASSERT_EQUAL_INT(listValues[index], value); - index++; + SKA_INPUT_KEY_KEYBOARD_FOR_EACH(key) { + TEST_ASSERT_TRUE(ska_input_is_keyboard_key(key)); + } + SKA_INPUT_KEY_MOUSE_FOR_EACH(key) { + TEST_ASSERT_TRUE(ska_input_is_mouse_key(key)); } - ska_array_list_remove_by_index(arrayList, 1); - int oneValue = (int)*(int*)ska_array_list_get(arrayList, 1); - TEST_ASSERT_EQUAL_INT(3, oneValue); + const char* backspaceKeyName = ska_input_key_to_string(SkaInputKey_KEYBOARD_BACKSPACE); + const SkaInputKey backSpaceKey = ska_input_string_to_key(backspaceKeyName); + TEST_ASSERT_EQUAL_STRING("Backspace", backspaceKeyName); + TEST_ASSERT_EQUAL_INT(SkaInputKey_KEYBOARD_BACKSPACE, backSpaceKey); - ska_array_list_remove(arrayList, &(int){3}); - oneValue = (int)*(int*)ska_array_list_get(arrayList, 1); - TEST_ASSERT_EQUAL_INT(5, oneValue); + TEST_MESSAGE("Testing events"); + ska_input_register_input_event3(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_BACKSPACE, SkaInputTriggerType_PRESSED); + TEST_ASSERT_TRUE(ska_input_is_key_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_TRUE(ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_key_just_released(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - ska_array_list_clear(arrayList); - TEST_ASSERT_TRUE(ska_array_list_is_empty(arrayList)); - ska_array_list_destroy(arrayList); -} + ska_input_register_input_event3(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_BACKSPACE, SkaInputTriggerType_PRESSED); + TEST_ASSERT_TRUE(ska_input_is_key_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_key_just_released(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); -void seika_id_queue_test(void) { - SkaIdQueue* idQueue = ska_id_queue_create(10); + ska_input_register_input_event3(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_BACKSPACE, SkaInputTriggerType_RELEASED); + TEST_ASSERT_FALSE(ska_input_is_key_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_TRUE(ska_input_is_key_just_released(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - uint32 value; - for (uint32 i = 0; i < 10; i++) { - ska_id_queue_dequeue(idQueue, &value); - TEST_ASSERT_EQUAL_UINT32(i, value); - } + TEST_MESSAGE("Testing input get axis input"); + ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y, SkaInputTriggerType_AXIS_IN_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, -0.5f); + const SkaVector2 firstAxisInput = ska_input_get_axis_input(SkaInputAxis_LEFT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); + TEST_ASSERT_EQUAL_FLOAT(0.0f, firstAxisInput.x); + TEST_ASSERT_EQUAL_FLOAT(-0.5f, firstAxisInput.y); - TEST_ASSERT_TRUE(ska_id_queue_is_empty(idQueue)); - - // - ska_id_queue_enqueue(idQueue, 4); - ska_id_queue_enqueue(idQueue, 6); - ska_id_queue_enqueue(idQueue, 5); - ska_id_queue_dequeue(idQueue, &value); - TEST_ASSERT_EQUAL_UINT32(4, value); - ska_id_queue_dequeue(idQueue, &value); - TEST_ASSERT_EQUAL_UINT32(6, value); - ska_id_queue_dequeue(idQueue, &value); - TEST_ASSERT_EQUAL_UINT32(5, value); - - ska_id_queue_dequeue(idQueue, &value); - TEST_ASSERT_EQUAL_UINT32(10, value); - TEST_ASSERT_EQUAL_size_t(20, idQueue->capacity); + ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X, SkaInputTriggerType_AXIS_IN_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.25f); + const SkaVector2 secondAxisInput = ska_input_get_axis_input(SkaInputAxis_LEFT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); + TEST_ASSERT_EQUAL_FLOAT(0.25f, secondAxisInput.x); + TEST_ASSERT_EQUAL_FLOAT(-0.5f, secondAxisInput.y); + + ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X, SkaInputTriggerType_AXIS_STOPPED_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.25f); + ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y, SkaInputTriggerType_AXIS_STOPPED_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.25f); + const SkaVector2 thirdAxisInput = ska_input_get_axis_input(SkaInputAxis_LEFT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); + TEST_ASSERT_EQUAL_FLOAT(0.0f, thirdAxisInput.x); + TEST_ASSERT_EQUAL_FLOAT(0.0f, thirdAxisInput.y); + + ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X, SkaInputTriggerType_AXIS_IN_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 1.0f); + const SkaVector2 fourthAxisInput = ska_input_get_axis_input(SkaInputAxis_RIGHT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); + TEST_ASSERT_EQUAL_FLOAT(1.0f, fourthAxisInput.x); + TEST_ASSERT_EQUAL_FLOAT(0.0f, fourthAxisInput.y); + + TEST_MESSAGE("Testing input actions"); + SkaInputActionHandle jumpActionHandle = ska_input_add_input_action( + "jump", + (SkaInputActionValue[]){ { .key = SkaInputKey_KEYBOARD_SPACE, .strengthThreshold = 0.5f }, { .key = SkaInputKey_KEYBOARD_RETURN, .strengthThreshold = 0.5f }, { SkaInputKey_INVALID } }, + SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX + ); + TEST_ASSERT_NOT_EQUAL_UINT32(SKA_INPUT_INVALID_INPUT_ACTION_HANDLE, jumpActionHandle); + jumpActionHandle = ska_input_find_input_action_handle("jump", SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); + TEST_ASSERT_NOT_EQUAL_UINT32(SKA_INPUT_INVALID_INPUT_ACTION_HANDLE, jumpActionHandle); + + ska_input_register_input_event(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_RETURN, SkaInputTriggerType_PRESSED, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.0f); + TEST_ASSERT_TRUE(ska_input_is_input_action_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_TRUE(ska_input_is_input_action_just_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_input_action_just_released(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_EQUAL_FLOAT(1.0f, ska_input_get_input_action_strength(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + + ska_input_new_frame(); + TEST_ASSERT_TRUE(ska_input_is_input_action_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_input_action_just_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_input_action_just_released(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + + ska_input_register_input_event(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_RETURN, SkaInputTriggerType_RELEASED, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.0f); + TEST_ASSERT_FALSE(ska_input_is_input_action_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_input_action_just_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_TRUE(ska_input_is_input_action_just_released(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + + ska_input_remove_input_action(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); + TEST_ASSERT_EQUAL_UINT32(SKA_INPUT_INVALID_INPUT_ACTION_HANDLE, ska_input_find_input_action_handle("jump", SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); } void seika_hash_map_test(void) { @@ -196,6 +207,74 @@ void seika_spatial_hash_map_test(void) { ska_spatial_hash_map_destroy(spatialHashMap); } +static bool linked_list_test_sort(void* a, void* b) { + int numA = (int) *(int*) a; + int numB = (int) *(int*) b; + return numA > numB; +} + +void seika_linked_list_test(void) { + SkaLinkedList* list = ska_linked_list_create(sizeof(int32)); + // Test prepend + int32 num1 = 9; + int32 num2 = 7; + ska_linked_list_prepend(list, &num1); + const int32 returnedNum = (int32) *(int32*) ska_linked_list_get_front(list); + TEST_ASSERT_EQUAL_INT(1, list->size); + TEST_ASSERT_EQUAL_INT(num1, returnedNum); + ska_linked_list_prepend(list, &num2); + TEST_ASSERT_EQUAL_INT(2, list->size); + ska_linked_list_remove(list, &num1); + TEST_ASSERT_EQUAL_INT(1, list->size); + int32* returnedNum2 = (int32*) ska_linked_list_pop_front(list); + TEST_ASSERT_EQUAL_INT(7, *returnedNum2); + TEST_ASSERT_TRUE(ska_linked_list_is_empty(list)); + SKA_MEM_FREE(returnedNum2); + + int32 numbers[5]; + for (int32 i = 0; i < 5; i++) { + numbers[i] = i; + ska_linked_list_append(list, &i); + } + TEST_ASSERT_EQUAL_INT(5, list->size); + + // For each loop test + SkaLinkedListNode* node = NULL; + int32 loopIndex = 0; + SKA_LINKED_LIST_FOR_EACH(list, node) { + const int32 indexNum = (int32)*(int32*)node->value; + TEST_ASSERT_EQUAL_INT(indexNum, numbers[loopIndex]); + loopIndex++; + } + + const int32 indexThreeNum = (int32)*(int32*)ska_linked_list_get(list, 3); + TEST_ASSERT_EQUAL_INT(3, indexThreeNum); + + // Insert Test + int32 insertNum1 = 10; + int32 insertNum2 = 20; + ska_linked_list_insert(list, &insertNum1, 3); + TEST_ASSERT_EQUAL_INT(6, list->size); + ska_linked_list_insert(list, &insertNum2, 1); + TEST_ASSERT_EQUAL_INT(7, list->size); + const int32 insertNumThree = (int32)*(int32*)ska_linked_list_get(list, 3); + TEST_ASSERT_EQUAL_INT(10, insertNumThree); + const int32 insertNumOne = (int32)*(int32*)ska_linked_list_get(list, 1); + TEST_ASSERT_EQUAL_INT(20, insertNumOne); + + ska_linked_list_sort(list, linked_list_test_sort); + const int32 smallestNum = (int32)*(int32*)ska_linked_list_get_front(list); + const int32 highestNum = (int32)*(int32*)ska_linked_list_get_back(list); + TEST_ASSERT_EQUAL_INT(0, smallestNum); + TEST_ASSERT_EQUAL_INT(20, highestNum); + + // Clear test + ska_linked_list_clear(list); + TEST_ASSERT_EQUAL_INT(0, list->size); + + ska_linked_list_destroy(list); +} + void seika_array2d_test(void) { typedef struct TestArrayStruct { int value; @@ -268,7 +347,121 @@ void seika_asset_file_loader_test(void) { ska_asset_file_loader_finalize(); } -#if SKA_ECS +// Observer Test +static bool hasObserved = false; + +void observer_func1(SkaSubjectNotifyPayload* payload) { + hasObserved = true; +} + +void observer_func2(SkaSubjectNotifyPayload* payload) { + const int dataValue = *(int*) payload->data; + if (dataValue == 3) { + hasObserved = true; + } +} + +void seika_observer_test(void) { + SkaEvent* event = ska_event_new(); + // Test 1 - Simple test with passing a NULL payload + SkaObserver* observer = ska_observer_new(observer_func1); + ska_event_register_observer(event, observer); + TEST_ASSERT_EQUAL_INT(1, event->observerCount); + ska_event_notify_observers(event, NULL); + TEST_ASSERT(hasObserved); + ska_event_unregister_observer(event, observer); + TEST_ASSERT_EQUAL_INT(0, event->observerCount); + hasObserved = false; + + // Test 2 - A slightly more complicated example filling out the payload + ska_observer_delete(observer); + observer = ska_observer_new(observer_func2); + ska_event_register_observer(event, observer); + int dataValue = 3; + ska_event_notify_observers(event, &(SkaSubjectNotifyPayload) { + .data = &dataValue + }); + TEST_ASSERT(hasObserved); + + // Clean up + ska_event_delete(event); + ska_observer_delete(observer); +} + +void seika_curve_float_test(void) { + SkaCurveFloat curve = { .controlPointCount = 0 }; + SkaCurveControlPoint point1 = { .x = 0.0, .y = 0.0, .tangentIn = 0.0, .tangentOut = 0.0 }; + ska_curve_float_add_control_point(&curve, point1); + TEST_ASSERT_EQUAL_UINT(1, curve.controlPointCount); + TEST_ASSERT_EQUAL_DOUBLE(0.0, ska_curve_float_eval(&curve, 1.0)); + SkaCurveControlPoint point2 = { .x = 1.0, .y = 1.0, .tangentIn = 0.0, .tangentOut = 0.0 }; + ska_curve_float_add_control_point(&curve, point2); + TEST_ASSERT_EQUAL_DOUBLE(0.0, ska_curve_float_eval(&curve, 0.0)); + TEST_ASSERT_EQUAL_DOUBLE(0.5, ska_curve_float_eval(&curve, 0.5)); + TEST_ASSERT_EQUAL_DOUBLE(1.0, ska_curve_float_eval(&curve, 1.0)); + ska_curve_float_remove_control_point(&curve, point2.x, point2.y); + TEST_ASSERT_EQUAL_UINT(1, curve.controlPointCount); + + // TODO: Write performance tests +// SE_PROFILE_CODE( +// for (int32 i = 0; i < 10000000; i++) {} +// ) +// +// f64 cpu_time_used; +// SE_PROFILE_CODE_WITH_VAR(cpu_time_used, for (int32 i = 0; i < 10000000; i++) {}) +// printf("Time taken: %f seconds\n", cpu_time_used); +} + +void seika_shader_instance_test(void) { + // Shader instance param tests + SkaShaderInstance shaderInstance = { .shader = NULL, .paramMap = ska_string_hash_map_create_default_capacity() }; + + ska_shader_instance_param_create_bool(&shaderInstance, "is_active", false); + TEST_ASSERT_FALSE(ska_shader_instance_param_get_bool(&shaderInstance, "is_active")); + ska_shader_instance_param_update_bool(&shaderInstance, "is_active", true); + TEST_ASSERT_TRUE(ska_shader_instance_param_get_bool(&shaderInstance, "is_active")); + + // Clean up + SKA_STRING_HASH_MAP_FOR_EACH(shaderInstance.paramMap, iter) { + SkaStringHashMapNode* node = iter.pair; + SkaShaderParam* param = (SkaShaderParam*) node->value; + SKA_MEM_FREE(param->name); + } + ska_string_hash_map_destroy(shaderInstance.paramMap); +} + +void seika_shader_file_parser_test(void) { + char shader[] = + "shader_type screen;\n" + "\n" + "uniform float time;\n" + "uniform vec2 size;\n" + "uniform float brightness = 1.0f;\n" + "uniform int spriteCount = 1;\n" + "\n" + "vec3 testFunc() {\n" + " return vec3(1.0f);\n" + "}\n" + "\n" + "void vertex() {\n" + " VERTEX.x += 0.1f;" + "}\n" + "\n" + "void fragment() {\n" + " COLOR *= brightness;\n" + "}\n" + "\n"; + SkaShaderFileParseResult result = ska_shader_file_parser_parse_shader(shader); + // Shouldn't be an error message + const bool hasErrorMessage = strlen(result.errorMessage) > 0; + if (hasErrorMessage) { + printf("Shader parse error = '%s'\n", result.errorMessage); + } + TEST_ASSERT_FALSE(hasErrorMessage); + ska_shader_file_parse_clear_parse_result(&result); +} + +// ECS TEST typedef struct TestValueComponent { int32 value; } TestValueComponent; @@ -363,93 +556,3 @@ void seika_ecs_test(void) { ska_ecs_finalize(); } -#endif - -#if SKA_INPUT - -void seika_input_test(void) { - TEST_MESSAGE("Testing 'for each' and checking input type"); - SKA_INPUT_KEY_GAMEPAD_FOR_EACH(key) { - TEST_ASSERT_TRUE(ska_input_is_gamepad_key(key)); - } - SKA_INPUT_KEY_KEYBOARD_FOR_EACH(key) { - TEST_ASSERT_TRUE(ska_input_is_keyboard_key(key)); - } - SKA_INPUT_KEY_MOUSE_FOR_EACH(key) { - TEST_ASSERT_TRUE(ska_input_is_mouse_key(key)); - } - - const char* backspaceKeyName = ska_input_key_to_string(SkaInputKey_KEYBOARD_BACKSPACE); - const SkaInputKey backSpaceKey = ska_input_string_to_key(backspaceKeyName); - TEST_ASSERT_EQUAL_STRING("Backspace", backspaceKeyName); - TEST_ASSERT_EQUAL_INT(SkaInputKey_KEYBOARD_BACKSPACE, backSpaceKey); - - TEST_MESSAGE("Testing events"); - ska_input_register_input_event3(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_BACKSPACE, SkaInputTriggerType_PRESSED); - TEST_ASSERT_TRUE(ska_input_is_key_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_TRUE(ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_key_just_released(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - - ska_input_register_input_event3(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_BACKSPACE, SkaInputTriggerType_PRESSED); - TEST_ASSERT_TRUE(ska_input_is_key_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_key_just_released(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - - ska_input_register_input_event3(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_BACKSPACE, SkaInputTriggerType_RELEASED); - TEST_ASSERT_FALSE(ska_input_is_key_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_TRUE(ska_input_is_key_just_released(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - - TEST_MESSAGE("Testing input get axis input"); - ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y, SkaInputTriggerType_AXIS_IN_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, -0.5f); - const SkaVector2 firstAxisInput = ska_input_get_axis_input(SkaInputAxis_LEFT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); - TEST_ASSERT_EQUAL_FLOAT(0.0f, firstAxisInput.x); - TEST_ASSERT_EQUAL_FLOAT(-0.5f, firstAxisInput.y); - - ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X, SkaInputTriggerType_AXIS_IN_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.25f); - const SkaVector2 secondAxisInput = ska_input_get_axis_input(SkaInputAxis_LEFT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); - TEST_ASSERT_EQUAL_FLOAT(0.25f, secondAxisInput.x); - TEST_ASSERT_EQUAL_FLOAT(-0.5f, secondAxisInput.y); - - ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X, SkaInputTriggerType_AXIS_STOPPED_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.25f); - ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y, SkaInputTriggerType_AXIS_STOPPED_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.25f); - const SkaVector2 thirdAxisInput = ska_input_get_axis_input(SkaInputAxis_LEFT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); - TEST_ASSERT_EQUAL_FLOAT(0.0f, thirdAxisInput.x); - TEST_ASSERT_EQUAL_FLOAT(0.0f, thirdAxisInput.y); - - ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X, SkaInputTriggerType_AXIS_IN_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 1.0f); - const SkaVector2 fourthAxisInput = ska_input_get_axis_input(SkaInputAxis_RIGHT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); - TEST_ASSERT_EQUAL_FLOAT(1.0f, fourthAxisInput.x); - TEST_ASSERT_EQUAL_FLOAT(0.0f, fourthAxisInput.y); - - TEST_MESSAGE("Testing input actions"); - SkaInputActionHandle jumpActionHandle = ska_input_add_input_action( - "jump", - (SkaInputActionValue[]){ { .key = SkaInputKey_KEYBOARD_SPACE, .strengthThreshold = 0.5f }, { .key = SkaInputKey_KEYBOARD_RETURN, .strengthThreshold = 0.5f }, { SkaInputKey_INVALID } }, - SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX - ); - TEST_ASSERT_NOT_EQUAL_UINT32(SKA_INPUT_INVALID_INPUT_ACTION_HANDLE, jumpActionHandle); - jumpActionHandle = ska_input_find_input_action_handle("jump", SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); - TEST_ASSERT_NOT_EQUAL_UINT32(SKA_INPUT_INVALID_INPUT_ACTION_HANDLE, jumpActionHandle); - - ska_input_register_input_event(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_RETURN, SkaInputTriggerType_PRESSED, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.0f); - TEST_ASSERT_TRUE(ska_input_is_input_action_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_TRUE(ska_input_is_input_action_just_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_input_action_just_released(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_EQUAL_FLOAT(1.0f, ska_input_get_input_action_strength(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - - ska_input_new_frame(); - TEST_ASSERT_TRUE(ska_input_is_input_action_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_input_action_just_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_input_action_just_released(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - - ska_input_register_input_event(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_RETURN, SkaInputTriggerType_RELEASED, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.0f); - TEST_ASSERT_FALSE(ska_input_is_input_action_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_input_action_just_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_TRUE(ska_input_is_input_action_just_released(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - - ska_input_remove_input_action(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); - TEST_ASSERT_EQUAL_UINT32(SKA_INPUT_INVALID_INPUT_ACTION_HANDLE, ska_input_find_input_action_handle("jump", SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); -} - -#endif // if SKA_INPUT diff --git a/test/test.c b/test/test.c index 2d09753..f8546e0 100644 --- a/test/test.c +++ b/test/test.c @@ -2,18 +2,21 @@ #include #include "seika/memory.h" -#include "seika/event.h" -#include "seika/input/input.h" -#include "seika/data_structures/hash_map.h" -#include "seika/data_structures/spatial_hash_map.h" +#include "seika/asset/asset_file_loader.h" #include "seika/data_structures/array2d.h" -#include "seika/data_structures/linked_list.h" -#include "seika/ecs/ec_system.h" +#include "seika/data_structures/array_list.h" +#include "seika/data_structures/id_queue.h" +#include "seika/data_structures/spatial_hash_map.h" +#include "seika/math/math.h" + +#if SKA_ECS #include "seika/ecs/ecs.h" -#include "seika/math/curve_float.h" -#include "seika/asset/asset_file_loader.h" -#include "seika/rendering/shader/shader_instance.h" -#include "seika/rendering/shader/shader_file_parser.h" +#include "seika/ecs/ec_system.h" +#endif + +#if SKA_INPUT +#include "seika/input/input.h" +#endif #define RESOURCES_PATH "test/resources" #define RESOURCES_PACK_PATH "test/resources/test.pck" @@ -21,118 +24,104 @@ void setUp(void) {} void tearDown(void) {} -void seika_input_test(void); +void seika_mem_test(void); +void seika_array_list_test(void); void seika_hash_map_test(void); void seika_spatial_hash_map_test(void); -void seika_linked_list_test(void); void seika_array2d_test(void); - +void seika_id_queue_test(void); void seika_asset_file_loader_test(void); -void seika_observer_test(void); -void seika_curve_float_test(void); -void seika_shader_instance_test(void); -void seika_shader_file_parser_test(void); + +#if SKA_ECS void seika_ecs_test(void); +#endif + +#if SKA_INPUT +void seika_input_test(void); +#endif int32 main(int32 argv, char** args) { UNITY_BEGIN(); - RUN_TEST(seika_input_test); + RUN_TEST(seika_mem_test); + RUN_TEST(seika_array_list_test); RUN_TEST(seika_hash_map_test); RUN_TEST(seika_spatial_hash_map_test); - RUN_TEST(seika_linked_list_test); RUN_TEST(seika_array2d_test); + RUN_TEST(seika_id_queue_test); RUN_TEST(seika_asset_file_loader_test); - RUN_TEST(seika_observer_test); - RUN_TEST(seika_curve_float_test); - RUN_TEST(seika_shader_instance_test); - RUN_TEST(seika_shader_file_parser_test); +#if SKA_ECS RUN_TEST(seika_ecs_test); +#endif +#if SKA_INPUT + RUN_TEST(seika_input_test); +#endif return UNITY_END(); } -void seika_input_test(void) { - TEST_MESSAGE("Testing 'for each' and checking input type"); - SKA_INPUT_KEY_GAMEPAD_FOR_EACH(key) { - TEST_ASSERT_TRUE(ska_input_is_gamepad_key(key)); - } - SKA_INPUT_KEY_KEYBOARD_FOR_EACH(key) { - TEST_ASSERT_TRUE(ska_input_is_keyboard_key(key)); - } - SKA_INPUT_KEY_MOUSE_FOR_EACH(key) { - TEST_ASSERT_TRUE(ska_input_is_mouse_key(key)); - } - - const char* backspaceKeyName = ska_input_key_to_string(SkaInputKey_KEYBOARD_BACKSPACE); - const SkaInputKey backSpaceKey = ska_input_string_to_key(backspaceKeyName); - TEST_ASSERT_EQUAL_STRING("Backspace", backspaceKeyName); - TEST_ASSERT_EQUAL_INT(SkaInputKey_KEYBOARD_BACKSPACE, backSpaceKey); - - TEST_MESSAGE("Testing events"); - ska_input_register_input_event3(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_BACKSPACE, SkaInputTriggerType_PRESSED); - TEST_ASSERT_TRUE(ska_input_is_key_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_TRUE(ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_key_just_released(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - - ska_input_register_input_event3(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_BACKSPACE, SkaInputTriggerType_PRESSED); - TEST_ASSERT_TRUE(ska_input_is_key_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_key_just_released(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - - ska_input_register_input_event3(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_BACKSPACE, SkaInputTriggerType_RELEASED); - TEST_ASSERT_FALSE(ska_input_is_key_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_TRUE(ska_input_is_key_just_released(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - - TEST_MESSAGE("Testing input get axis input"); - ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y, SkaInputTriggerType_AXIS_IN_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, -0.5f); - const SkaVector2 firstAxisInput = ska_input_get_axis_input(SkaInputAxis_LEFT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); - TEST_ASSERT_EQUAL_FLOAT(0.0f, firstAxisInput.x); - TEST_ASSERT_EQUAL_FLOAT(-0.5f, firstAxisInput.y); +void seika_mem_test(void) { + int* testInt = SKA_ALLOC(int); + TEST_ASSERT_NOT_NULL(testInt); + *testInt = 5; + TEST_ASSERT_EQUAL_INT(5, *testInt); + TEST_ASSERT_TRUE(ska_mem_report_leaks()); + SKA_FREE(testInt); + TEST_ASSERT_FALSE(ska_mem_report_leaks()); +} - ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X, SkaInputTriggerType_AXIS_IN_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.25f); - const SkaVector2 secondAxisInput = ska_input_get_axis_input(SkaInputAxis_LEFT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); - TEST_ASSERT_EQUAL_FLOAT(0.25f, secondAxisInput.x); - TEST_ASSERT_EQUAL_FLOAT(-0.5f, secondAxisInput.y); +void seika_array_list_test(void) { + int listValues[] = { 8, 2, 3, 5 }; + SkaArrayList* arrayList = ska_array_list_create_default_capacity(sizeof(int)); + TEST_ASSERT_TRUE(ska_array_list_is_empty(arrayList)); - ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X, SkaInputTriggerType_AXIS_STOPPED_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.25f); - ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y, SkaInputTriggerType_AXIS_STOPPED_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.25f); - const SkaVector2 thirdAxisInput = ska_input_get_axis_input(SkaInputAxis_LEFT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); - TEST_ASSERT_EQUAL_FLOAT(0.0f, thirdAxisInput.x); - TEST_ASSERT_EQUAL_FLOAT(0.0f, thirdAxisInput.y); + for (int i = 0; i < 4; i++) { + ska_array_list_push_back(arrayList, &listValues[i]); + } + TEST_ASSERT_FALSE(ska_array_list_is_empty(arrayList)); + int index = 0; + SKA_ARRAY_LIST_FOR_EACH(arrayList, int, i) { + const int value = (int)*(int*)ska_array_list_get(arrayList, index); + TEST_ASSERT_EQUAL_INT(listValues[index], value); + index++; + } - ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X, SkaInputTriggerType_AXIS_IN_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 1.0f); - const SkaVector2 fourthAxisInput = ska_input_get_axis_input(SkaInputAxis_RIGHT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); - TEST_ASSERT_EQUAL_FLOAT(1.0f, fourthAxisInput.x); - TEST_ASSERT_EQUAL_FLOAT(0.0f, fourthAxisInput.y); + ska_array_list_remove_by_index(arrayList, 1); + int oneValue = (int)*(int*)ska_array_list_get(arrayList, 1); + TEST_ASSERT_EQUAL_INT(3, oneValue); - TEST_MESSAGE("Testing input actions"); - SkaInputActionHandle jumpActionHandle = ska_input_add_input_action( - "jump", - (SkaInputActionValue[]){ { .key = SkaInputKey_KEYBOARD_SPACE, .strengthThreshold = 0.5f }, { .key = SkaInputKey_KEYBOARD_RETURN, .strengthThreshold = 0.5f }, { SkaInputKey_INVALID } }, - SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX - ); - TEST_ASSERT_NOT_EQUAL_UINT32(SKA_INPUT_INVALID_INPUT_ACTION_HANDLE, jumpActionHandle); - jumpActionHandle = ska_input_find_input_action_handle("jump", SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); - TEST_ASSERT_NOT_EQUAL_UINT32(SKA_INPUT_INVALID_INPUT_ACTION_HANDLE, jumpActionHandle); + ska_array_list_remove(arrayList, &(int){3}); + oneValue = (int)*(int*)ska_array_list_get(arrayList, 1); + TEST_ASSERT_EQUAL_INT(5, oneValue); - ska_input_register_input_event(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_RETURN, SkaInputTriggerType_PRESSED, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.0f); - TEST_ASSERT_TRUE(ska_input_is_input_action_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_TRUE(ska_input_is_input_action_just_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_input_action_just_released(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_EQUAL_FLOAT(1.0f, ska_input_get_input_action_strength(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + ska_array_list_clear(arrayList); + TEST_ASSERT_TRUE(ska_array_list_is_empty(arrayList)); + ska_array_list_destroy(arrayList); +} - ska_input_new_frame(); - TEST_ASSERT_TRUE(ska_input_is_input_action_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_input_action_just_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_input_action_just_released(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); +void seika_id_queue_test(void) { + SkaIdQueue* idQueue = ska_id_queue_create(10); - ska_input_register_input_event(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_RETURN, SkaInputTriggerType_RELEASED, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.0f); - TEST_ASSERT_FALSE(ska_input_is_input_action_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_input_action_just_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_TRUE(ska_input_is_input_action_just_released(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + uint32 value; + for (uint32 i = 0; i < 10; i++) { + ska_id_queue_dequeue(idQueue, &value); + TEST_ASSERT_EQUAL_UINT32(i, value); + } - ska_input_remove_input_action(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); - TEST_ASSERT_EQUAL_UINT32(SKA_INPUT_INVALID_INPUT_ACTION_HANDLE, ska_input_find_input_action_handle("jump", SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_TRUE(ska_id_queue_is_empty(idQueue)); + + // + ska_id_queue_enqueue(idQueue, 4); + ska_id_queue_enqueue(idQueue, 6); + ska_id_queue_enqueue(idQueue, 5); + ska_id_queue_dequeue(idQueue, &value); + TEST_ASSERT_EQUAL_UINT32(4, value); + ska_id_queue_dequeue(idQueue, &value); + TEST_ASSERT_EQUAL_UINT32(6, value); + ska_id_queue_dequeue(idQueue, &value); + TEST_ASSERT_EQUAL_UINT32(5, value); + + ska_id_queue_dequeue(idQueue, &value); + TEST_ASSERT_EQUAL_UINT32(10, value); + TEST_ASSERT_EQUAL_size_t(20, idQueue->capacity); } void seika_hash_map_test(void) { @@ -207,74 +196,6 @@ void seika_spatial_hash_map_test(void) { ska_spatial_hash_map_destroy(spatialHashMap); } -static bool linked_list_test_sort(void* a, void* b) { - int numA = (int) *(int*) a; - int numB = (int) *(int*) b; - return numA > numB; -} - -void seika_linked_list_test(void) { - SkaLinkedList* list = ska_linked_list_create(sizeof(int32)); - // Test prepend - int32 num1 = 9; - int32 num2 = 7; - ska_linked_list_prepend(list, &num1); - const int32 returnedNum = (int32) *(int32*) ska_linked_list_get_front(list); - TEST_ASSERT_EQUAL_INT(1, list->size); - TEST_ASSERT_EQUAL_INT(num1, returnedNum); - ska_linked_list_prepend(list, &num2); - TEST_ASSERT_EQUAL_INT(2, list->size); - ska_linked_list_remove(list, &num1); - TEST_ASSERT_EQUAL_INT(1, list->size); - int32* returnedNum2 = (int32*) ska_linked_list_pop_front(list); - TEST_ASSERT_EQUAL_INT(7, *returnedNum2); - TEST_ASSERT_TRUE(ska_linked_list_is_empty(list)); - SKA_MEM_FREE(returnedNum2); - - int32 numbers[5]; - for (int32 i = 0; i < 5; i++) { - numbers[i] = i; - ska_linked_list_append(list, &i); - } - TEST_ASSERT_EQUAL_INT(5, list->size); - - // For each loop test - SkaLinkedListNode* node = NULL; - int32 loopIndex = 0; - SKA_LINKED_LIST_FOR_EACH(list, node) { - const int32 indexNum = (int32)*(int32*)node->value; - TEST_ASSERT_EQUAL_INT(indexNum, numbers[loopIndex]); - loopIndex++; - } - - const int32 indexThreeNum = (int32)*(int32*)ska_linked_list_get(list, 3); - TEST_ASSERT_EQUAL_INT(3, indexThreeNum); - - // Insert Test - int32 insertNum1 = 10; - int32 insertNum2 = 20; - ska_linked_list_insert(list, &insertNum1, 3); - TEST_ASSERT_EQUAL_INT(6, list->size); - ska_linked_list_insert(list, &insertNum2, 1); - TEST_ASSERT_EQUAL_INT(7, list->size); - const int32 insertNumThree = (int32)*(int32*)ska_linked_list_get(list, 3); - TEST_ASSERT_EQUAL_INT(10, insertNumThree); - const int32 insertNumOne = (int32)*(int32*)ska_linked_list_get(list, 1); - TEST_ASSERT_EQUAL_INT(20, insertNumOne); - - ska_linked_list_sort(list, linked_list_test_sort); - const int32 smallestNum = (int32)*(int32*)ska_linked_list_get_front(list); - const int32 highestNum = (int32)*(int32*)ska_linked_list_get_back(list); - TEST_ASSERT_EQUAL_INT(0, smallestNum); - TEST_ASSERT_EQUAL_INT(20, highestNum); - - // Clear test - ska_linked_list_clear(list); - TEST_ASSERT_EQUAL_INT(0, list->size); - - ska_linked_list_destroy(list); -} - void seika_array2d_test(void) { typedef struct TestArrayStruct { int value; @@ -347,121 +268,7 @@ void seika_asset_file_loader_test(void) { ska_asset_file_loader_finalize(); } -// Observer Test -static bool hasObserved = false; - -void observer_func1(SkaSubjectNotifyPayload* payload) { - hasObserved = true; -} - -void observer_func2(SkaSubjectNotifyPayload* payload) { - const int dataValue = *(int*) payload->data; - if (dataValue == 3) { - hasObserved = true; - } -} - -void seika_observer_test(void) { - SkaEvent* event = ska_event_new(); - // Test 1 - Simple test with passing a NULL payload - SkaObserver* observer = ska_observer_new(observer_func1); - ska_event_register_observer(event, observer); - TEST_ASSERT_EQUAL_INT(1, event->observerCount); - ska_event_notify_observers(event, NULL); - TEST_ASSERT(hasObserved); - ska_event_unregister_observer(event, observer); - TEST_ASSERT_EQUAL_INT(0, event->observerCount); - hasObserved = false; - - // Test 2 - A slightly more complicated example filling out the payload - ska_observer_delete(observer); - observer = ska_observer_new(observer_func2); - ska_event_register_observer(event, observer); - int dataValue = 3; - ska_event_notify_observers(event, &(SkaSubjectNotifyPayload) { - .data = &dataValue - }); - TEST_ASSERT(hasObserved); - - // Clean up - ska_event_delete(event); - ska_observer_delete(observer); -} - -void seika_curve_float_test(void) { - SkaCurveFloat curve = { .controlPointCount = 0 }; - SkaCurveControlPoint point1 = { .x = 0.0, .y = 0.0, .tangentIn = 0.0, .tangentOut = 0.0 }; - ska_curve_float_add_control_point(&curve, point1); - TEST_ASSERT_EQUAL_UINT(1, curve.controlPointCount); - TEST_ASSERT_EQUAL_DOUBLE(0.0, ska_curve_float_eval(&curve, 1.0)); - SkaCurveControlPoint point2 = { .x = 1.0, .y = 1.0, .tangentIn = 0.0, .tangentOut = 0.0 }; - ska_curve_float_add_control_point(&curve, point2); - TEST_ASSERT_EQUAL_DOUBLE(0.0, ska_curve_float_eval(&curve, 0.0)); - TEST_ASSERT_EQUAL_DOUBLE(0.5, ska_curve_float_eval(&curve, 0.5)); - TEST_ASSERT_EQUAL_DOUBLE(1.0, ska_curve_float_eval(&curve, 1.0)); - ska_curve_float_remove_control_point(&curve, point2.x, point2.y); - TEST_ASSERT_EQUAL_UINT(1, curve.controlPointCount); - - // TODO: Write performance tests -// SE_PROFILE_CODE( -// for (int32 i = 0; i < 10000000; i++) {} -// ) -// -// f64 cpu_time_used; -// SE_PROFILE_CODE_WITH_VAR(cpu_time_used, for (int32 i = 0; i < 10000000; i++) {}) -// printf("Time taken: %f seconds\n", cpu_time_used); -} - -void seika_shader_instance_test(void) { - // Shader instance param tests - SkaShaderInstance shaderInstance = { .shader = NULL, .paramMap = ska_string_hash_map_create_default_capacity() }; - - ska_shader_instance_param_create_bool(&shaderInstance, "is_active", false); - TEST_ASSERT_FALSE(ska_shader_instance_param_get_bool(&shaderInstance, "is_active")); - ska_shader_instance_param_update_bool(&shaderInstance, "is_active", true); - TEST_ASSERT_TRUE(ska_shader_instance_param_get_bool(&shaderInstance, "is_active")); - - // Clean up - SKA_STRING_HASH_MAP_FOR_EACH(shaderInstance.paramMap, iter) { - SkaStringHashMapNode* node = iter.pair; - SkaShaderParam* param = (SkaShaderParam*) node->value; - SKA_MEM_FREE(param->name); - } - ska_string_hash_map_destroy(shaderInstance.paramMap); -} - -void seika_shader_file_parser_test(void) { - char shader[] = - "shader_type screen;\n" - "\n" - "uniform float time;\n" - "uniform vec2 size;\n" - "uniform float brightness = 1.0f;\n" - "uniform int spriteCount = 1;\n" - "\n" - "vec3 testFunc() {\n" - " return vec3(1.0f);\n" - "}\n" - "\n" - "void vertex() {\n" - " VERTEX.x += 0.1f;" - "}\n" - "\n" - "void fragment() {\n" - " COLOR *= brightness;\n" - "}\n" - "\n"; - SkaShaderFileParseResult result = ska_shader_file_parser_parse_shader(shader); - // Shouldn't be an error message - const bool hasErrorMessage = strlen(result.errorMessage) > 0; - if (hasErrorMessage) { - printf("Shader parse error = '%s'\n", result.errorMessage); - } - TEST_ASSERT_FALSE(hasErrorMessage); - ska_shader_file_parse_clear_parse_result(&result); -} - -// ECS TEST +#if SKA_ECS typedef struct TestValueComponent { int32 value; } TestValueComponent; @@ -556,3 +363,93 @@ void seika_ecs_test(void) { ska_ecs_finalize(); } +#endif + +#if SKA_INPUT + +void seika_input_test(void) { + TEST_MESSAGE("Testing 'for each' and checking input type"); + SKA_INPUT_KEY_GAMEPAD_FOR_EACH(key) { + TEST_ASSERT_TRUE(ska_input_is_gamepad_key(key)); + } + SKA_INPUT_KEY_KEYBOARD_FOR_EACH(key) { + TEST_ASSERT_TRUE(ska_input_is_keyboard_key(key)); + } + SKA_INPUT_KEY_MOUSE_FOR_EACH(key) { + TEST_ASSERT_TRUE(ska_input_is_mouse_key(key)); + } + + const char* backspaceKeyName = ska_input_key_to_string(SkaInputKey_KEYBOARD_BACKSPACE); + const SkaInputKey backSpaceKey = ska_input_string_to_key(backspaceKeyName); + TEST_ASSERT_EQUAL_STRING("Backspace", backspaceKeyName); + TEST_ASSERT_EQUAL_INT(SkaInputKey_KEYBOARD_BACKSPACE, backSpaceKey); + + TEST_MESSAGE("Testing events"); + ska_input_register_input_event3(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_BACKSPACE, SkaInputTriggerType_PRESSED); + TEST_ASSERT_TRUE(ska_input_is_key_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_TRUE(ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_key_just_released(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + + ska_input_register_input_event3(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_BACKSPACE, SkaInputTriggerType_PRESSED); + TEST_ASSERT_TRUE(ska_input_is_key_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_key_just_released(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + + ska_input_register_input_event3(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_BACKSPACE, SkaInputTriggerType_RELEASED); + TEST_ASSERT_FALSE(ska_input_is_key_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_TRUE(ska_input_is_key_just_released(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + + TEST_MESSAGE("Testing input get axis input"); + ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y, SkaInputTriggerType_AXIS_IN_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, -0.5f); + const SkaVector2 firstAxisInput = ska_input_get_axis_input(SkaInputAxis_LEFT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); + TEST_ASSERT_EQUAL_FLOAT(0.0f, firstAxisInput.x); + TEST_ASSERT_EQUAL_FLOAT(-0.5f, firstAxisInput.y); + + ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X, SkaInputTriggerType_AXIS_IN_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.25f); + const SkaVector2 secondAxisInput = ska_input_get_axis_input(SkaInputAxis_LEFT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); + TEST_ASSERT_EQUAL_FLOAT(0.25f, secondAxisInput.x); + TEST_ASSERT_EQUAL_FLOAT(-0.5f, secondAxisInput.y); + + ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X, SkaInputTriggerType_AXIS_STOPPED_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.25f); + ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y, SkaInputTriggerType_AXIS_STOPPED_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.25f); + const SkaVector2 thirdAxisInput = ska_input_get_axis_input(SkaInputAxis_LEFT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); + TEST_ASSERT_EQUAL_FLOAT(0.0f, thirdAxisInput.x); + TEST_ASSERT_EQUAL_FLOAT(0.0f, thirdAxisInput.y); + + ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X, SkaInputTriggerType_AXIS_IN_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 1.0f); + const SkaVector2 fourthAxisInput = ska_input_get_axis_input(SkaInputAxis_RIGHT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); + TEST_ASSERT_EQUAL_FLOAT(1.0f, fourthAxisInput.x); + TEST_ASSERT_EQUAL_FLOAT(0.0f, fourthAxisInput.y); + + TEST_MESSAGE("Testing input actions"); + SkaInputActionHandle jumpActionHandle = ska_input_add_input_action( + "jump", + (SkaInputActionValue[]){ { .key = SkaInputKey_KEYBOARD_SPACE, .strengthThreshold = 0.5f }, { .key = SkaInputKey_KEYBOARD_RETURN, .strengthThreshold = 0.5f }, { SkaInputKey_INVALID } }, + SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX + ); + TEST_ASSERT_NOT_EQUAL_UINT32(SKA_INPUT_INVALID_INPUT_ACTION_HANDLE, jumpActionHandle); + jumpActionHandle = ska_input_find_input_action_handle("jump", SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); + TEST_ASSERT_NOT_EQUAL_UINT32(SKA_INPUT_INVALID_INPUT_ACTION_HANDLE, jumpActionHandle); + + ska_input_register_input_event(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_RETURN, SkaInputTriggerType_PRESSED, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.0f); + TEST_ASSERT_TRUE(ska_input_is_input_action_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_TRUE(ska_input_is_input_action_just_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_input_action_just_released(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_EQUAL_FLOAT(1.0f, ska_input_get_input_action_strength(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + + ska_input_new_frame(); + TEST_ASSERT_TRUE(ska_input_is_input_action_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_input_action_just_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_input_action_just_released(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + + ska_input_register_input_event(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_RETURN, SkaInputTriggerType_RELEASED, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.0f); + TEST_ASSERT_FALSE(ska_input_is_input_action_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_FALSE(ska_input_is_input_action_just_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + TEST_ASSERT_TRUE(ska_input_is_input_action_just_released(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); + + ska_input_remove_input_action(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); + TEST_ASSERT_EQUAL_UINT32(SKA_INPUT_INVALID_INPUT_ACTION_HANDLE, ska_input_find_input_action_handle("jump", SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); +} + +#endif // if SKA_INPUT From 70147761fca8ad9bd9cea60bcd8028ac72e0992b Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Fri, 18 Oct 2024 00:30:40 -0400 Subject: [PATCH 29/55] Updates. --- seika/asset/asset_manager.c | 10 ++--- seika/audio/audio.c | 4 +- seika/rendering/shader/shader.c | 2 +- seika/rendering/shader/shader_cache.c | 4 +- seika/rendering/shader/shader_file_parser.c | 44 ++++++++++----------- seika/thread/thread_pool.c | 8 ++-- 6 files changed, 36 insertions(+), 36 deletions(-) diff --git a/seika/asset/asset_manager.c b/seika/asset/asset_manager.c index 8048731..e89e2cd 100644 --- a/seika/asset/asset_manager.c +++ b/seika/asset/asset_manager.c @@ -30,7 +30,7 @@ SkaTexture* ska_asset_manager_load_texture(const char* fileName, const char* key SKA_ASSERT_FMT(!ska_string_hash_map_has(texturesMap, fileName), "Already loaded texture at file path '%'s! Has key '%s'.", fileName, key); SkaTexture* texture = ska_texture_create_texture(fileName); ska_string_hash_map_add(texturesMap, key, texture, sizeof(SkaTexture)); - SKA_MEM_FREE(texture); + SKA_FREE(texture); texture = (SkaTexture*) ska_string_hash_map_get(texturesMap, key); return texture; } @@ -45,7 +45,7 @@ SkaTexture* ska_asset_manager_load_texture_ex(const char* fileName, const char* applyNearestNeighbor ); ska_string_hash_map_add(texturesMap, key, texture, sizeof(SkaTexture)); - SKA_MEM_FREE(texture); + SKA_FREE(texture); texture = (SkaTexture*) ska_string_hash_map_get(texturesMap, key); return texture; } @@ -64,7 +64,7 @@ SkaFont* ska_asset_manager_load_font(const char* fileName, const char* key, int SkaFont* font = ska_font_create_font(fileName, size, applyNearestNeighbor); SKA_ASSERT_FMT(font != NULL, "Failed to load font! file_name: '%s', key: '%s', size: '%d'", fileName, key, size); ska_string_hash_map_add(fontMap, key, font, sizeof(SkaFont)); - SKA_MEM_FREE(font); + SKA_FREE(font); font = (SkaFont*) ska_string_hash_map_get(fontMap, key); return font; } @@ -74,7 +74,7 @@ SkaFont* ska_asset_manager_load_font_from_memory(const char* key, void* buffer, SkaFont* font = ska_font_create_font_from_memory(buffer, bufferSize, size, applyNearestNeighbor); SKA_ASSERT_FMT(font != NULL, "Failed to load font! key: '%s', size: '%d'", key, size); ska_string_hash_map_add(fontMap, key, font, sizeof(SkaFont)); - SKA_MEM_FREE(font); + SKA_FREE(font); font = (SkaFont*) ska_string_hash_map_get(fontMap, key); return font; } @@ -97,7 +97,7 @@ SkaAudioSource* ska_asset_manager_load_audio_source_wav(const char* fileName, co SkaAudioSource* newAudioSource = ska_audio_load_audio_source_wav(fileName); SKA_ASSERT_FMT(newAudioSource != NULL, "Audio source is null! file_name = '%s', key = '%s'", fileName, key); ska_string_hash_map_add(audioSourceMap, key, newAudioSource, sizeof(SkaAudioSource)); - SKA_MEM_FREE(newAudioSource); + SKA_FREE(newAudioSource); return newAudioSource; } diff --git a/seika/audio/audio.c b/seika/audio/audio.c index 823944e..32a1e34 100644 --- a/seika/audio/audio.c +++ b/seika/audio/audio.c @@ -35,7 +35,7 @@ SkaAudioSource* ska_audio_load_audio_source_wav(const char* fileName) { ska_logger_error("Failed to load audio wav file at '%s'", fileName); return NULL; } - SkaAudioSource* newAudioSource = (SkaAudioSource*)SKA_MEM_ALLOCATE_SIZE(sizeof(SkaAudioSource*) + (sampleCount * sizeof(int16_t*))); + SkaAudioSource* newAudioSource = (SkaAudioSource*)SKA_ALLOC_BYTES(sizeof(SkaAudioSource*) + (sampleCount * sizeof(int16_t*))); newAudioSource->file_path = fileName; newAudioSource->pitch = 1.0; newAudioSource->sample_count = sampleCount; @@ -58,7 +58,7 @@ bool load_wav_data_from_file(const char* file_path, int32_t* sample_count, int32 drwav_uint64 totalPcmFrameCount = 0; *samples = drwav_open_memory_and_read_pcm_frames_s16(file_data, len, (uint32_t*)channels, (uint32_t*)sample_rate, &totalPcmFrameCount, NULL); - SKA_MEM_FREE(file_data); + SKA_FREE(file_data); if (!*samples) { *samples = NULL; diff --git a/seika/rendering/shader/shader.c b/seika/rendering/shader/shader.c index 24ce965..897d274 100644 --- a/seika/rendering/shader/shader.c +++ b/seika/rendering/shader/shader.c @@ -36,7 +36,7 @@ SkaShader* ska_shader_compile_new_shader(const char* vertexSource, const char* f } void ska_shader_destroy(SkaShader* shader) { - SKA_MEM_FREE(shader); + SKA_FREE(shader); } bool shader_check_compile_errors(uint32 shaderId, const char* type) { diff --git a/seika/rendering/shader/shader_cache.c b/seika/rendering/shader/shader_cache.c index 8d01be8..fea201a 100644 --- a/seika/rendering/shader/shader_cache.c +++ b/seika/rendering/shader/shader_cache.c @@ -109,8 +109,8 @@ SkaShaderInstanceId ska_shader_cache_create_instance_and_add_from_raw(const char char* vertexSource = ska_asset_file_loader_read_file_contents_as_string(vertexPath, NULL); char* fragmentSource = ska_asset_file_loader_read_file_contents_as_string(fragmentPath, NULL); const SkaShaderInstanceId newId = ska_shader_cache_create_instance_and_add_from_source(vertexSource, fragmentSource); - SKA_MEM_FREE(vertexSource); - SKA_MEM_FREE(fragmentSource); + SKA_FREE(vertexSource); + SKA_FREE(fragmentSource); return newId; } diff --git a/seika/rendering/shader/shader_file_parser.c b/seika/rendering/shader/shader_file_parser.c index 5b9a3ba..65581a5 100644 --- a/seika/rendering/shader/shader_file_parser.c +++ b/seika/rendering/shader/shader_file_parser.c @@ -10,12 +10,12 @@ #define SHADER_FILE_PARSER_ERROR_RETURN(RESULT, SOURCE, MESSAGE) \ ska_strcpy((RESULT).errorMessage, (MESSAGE)); \ -SKA_MEM_FREE((SOURCE)); \ +SKA_FREE((SOURCE)); \ return (RESULT); #define SHADER_FILE_PARSER_ERROR_FMT_RETURN(RESULT, SOURCE, FMT, ...) \ sprintf((RESULT).errorMessage, (FMT), ##__VA_ARGS__); \ -SKA_MEM_FREE((SOURCE)); \ +SKA_FREE((SOURCE)); \ return (RESULT); static char* shader_file_parse_data_get_full_uniforms_source(SkaShaderFileParseData* parseData) { @@ -74,11 +74,11 @@ char* shader_file_parse_data_get_full_functions_source(SkaShaderFileParseData* p } void shader_file_parse_data_delete_internal_memory(SkaShaderFileParseData* parseData) { - SKA_MEM_FREE(parseData->fullVertexSource); - SKA_MEM_FREE(parseData->fullFragmentSource); + SKA_FREE(parseData->fullVertexSource); + SKA_FREE(parseData->fullFragmentSource); for (usize i = 0; i < parseData->functionCount; i++) { - SKA_MEM_FREE(parseData->functions[i].name); - SKA_MEM_FREE(parseData->functions[i].fullFunctionSource); + SKA_FREE(parseData->functions[i].name); + SKA_FREE(parseData->functions[i].fullFunctionSource); } } @@ -464,12 +464,12 @@ SkaShaderFileParseResult ska_shader_file_parser_parse_shader(const char* shaderS // Check for vertex and fragment shader functions if (strcmp(parsedFunction.name, "vertex") == 0) { result.parseData.vertexFunctionSource = shader_file_parse_function_body(parsedFunction.fullFunctionSource); - SKA_MEM_FREE(parsedFunction.name); - SKA_MEM_FREE(parsedFunction.fullFunctionSource); + SKA_FREE(parsedFunction.name); + SKA_FREE(parsedFunction.fullFunctionSource); } else if (strcmp(parsedFunction.name, "fragment") == 0) { result.parseData.fragmentFunctionSource = shader_file_parse_function_body(parsedFunction.fullFunctionSource); - SKA_MEM_FREE(parsedFunction.name); - SKA_MEM_FREE(parsedFunction.fullFunctionSource); + SKA_FREE(parsedFunction.name); + SKA_FREE(parsedFunction.fullFunctionSource); } else { // Add non vertex and fragment functions to our array result.parseData.functions[result.parseData.functionCount++] = parsedFunction; @@ -506,7 +506,7 @@ SkaShaderFileParseResult ska_shader_file_parser_parse_shader(const char* shaderS foundUniformsToken + SHADER_UNIFORMS_REPLACE_TOKEN_LENGTH, strlen(foundUniformsToken + SHADER_UNIFORMS_REPLACE_TOKEN_LENGTH) + 1); memcpy(foundUniformsToken, uniformsSource, uniformsReplaceLength); - SKA_MEM_FREE(uniformsSource); + SKA_FREE(uniformsSource); } // Vertex functions char* foundFunctionsToken = strstr(fullShaderBuffer, SHADER_FUNCTIONS_REPLACE_TOKEN); @@ -520,7 +520,7 @@ SkaShaderFileParseResult ska_shader_file_parser_parse_shader(const char* shaderS foundFunctionsToken + SHADER_FUNCTIONS_REPLACE_TOKEN_LENGTH, strlen(foundFunctionsToken + SHADER_FUNCTIONS_REPLACE_TOKEN_LENGTH) + 1); memcpy(foundFunctionsToken, functionsSource, functionsReplaceLength); - SKA_MEM_FREE(functionsSource); + SKA_FREE(functionsSource); } // Vertex body char* foundVertexToken = strstr(fullShaderBuffer, SHADER_VERTEX_BODY_REPLACE_TOKEN); @@ -551,7 +551,7 @@ SkaShaderFileParseResult ska_shader_file_parser_parse_shader(const char* shaderS foundUniformsToken + SHADER_UNIFORMS_REPLACE_TOKEN_LENGTH, strlen(foundUniformsToken + SHADER_UNIFORMS_REPLACE_TOKEN_LENGTH) + 1); memcpy(foundUniformsToken, uniformsSource, uniformsReplaceLength); - SKA_MEM_FREE(uniformsSource); + SKA_FREE(uniformsSource); } // Fragment functions char* foundFunctionsToken = strstr(fullShaderBuffer, SHADER_FUNCTIONS_REPLACE_TOKEN); @@ -565,7 +565,7 @@ SkaShaderFileParseResult ska_shader_file_parser_parse_shader(const char* shaderS foundFunctionsToken + SHADER_FUNCTIONS_REPLACE_TOKEN_LENGTH, strlen(foundFunctionsToken + SHADER_FUNCTIONS_REPLACE_TOKEN_LENGTH) + 1); memcpy(foundFunctionsToken, functionsSource, functionsReplaceLength); - SKA_MEM_FREE(functionsSource); + SKA_FREE(functionsSource); } // Fragment body char* foundFragmentToken = strstr(fullShaderBuffer, SHADER_FRAGMENT_BODY_REPLACE_TOKEN); @@ -581,30 +581,30 @@ SkaShaderFileParseResult ska_shader_file_parser_parse_shader(const char* shaderS // printf("FULL FRAGMENT SOURCE = \n%s\n", fullShaderBuffer); result.parseData.fullFragmentSource = ska_strdup(fullShaderBuffer); - SKA_MEM_FREE(originalSource); + SKA_FREE(originalSource); return result; } void ska_shader_file_parse_clear_parse_result(SkaShaderFileParseResult* result) { if (result->parseData.fragmentFunctionSource) { - SKA_MEM_FREE(result->parseData.fragmentFunctionSource); + SKA_FREE(result->parseData.fragmentFunctionSource); } if (result->parseData.vertexFunctionSource) { - SKA_MEM_FREE(result->parseData.vertexFunctionSource); + SKA_FREE(result->parseData.vertexFunctionSource); } if (result->parseData.fullVertexSource) { - SKA_MEM_FREE(result->parseData.fullVertexSource); + SKA_FREE(result->parseData.fullVertexSource); } if (result->parseData.fullFragmentSource) { - SKA_MEM_FREE(result->parseData.fullFragmentSource); + SKA_FREE(result->parseData.fullFragmentSource); } for (usize i = 0; i < result->parseData.uniformCount; i++) { - SKA_MEM_FREE(result->parseData.uniforms[i].name); + SKA_FREE(result->parseData.uniforms[i].name); } for (usize i = 0; i < result->parseData.functionCount; i++) { - SKA_MEM_FREE(result->parseData.functions[i].name); - SKA_MEM_FREE(result->parseData.functions[i].fullFunctionSource); + SKA_FREE(result->parseData.functions[i].name); + SKA_FREE(result->parseData.functions[i].fullFunctionSource); } } diff --git a/seika/thread/thread_pool.c b/seika/thread/thread_pool.c index dc975e3..8a193b4 100644 --- a/seika/thread/thread_pool.c +++ b/seika/thread/thread_pool.c @@ -10,7 +10,7 @@ static SkaThreadPoolWork* tpool_work_create(SkaThreadFunc func, void *arg) { return NULL; } - work = SKA_MEM_ALLOCATE_SIZE(sizeof(*work)); + work = SKA_ALLOC_BYTES(sizeof(*work)); work->func = func; work->arg = arg; work->next = NULL; @@ -21,7 +21,7 @@ static void tpool_work_destroy(SkaThreadPoolWork* work) { if (work == NULL) { return; } - SKA_MEM_FREE(work); + SKA_FREE(work); } @@ -95,7 +95,7 @@ SkaThreadPool* ska_tpool_create(usize num) { num = 2; } - tp = SKA_MEM_ALLOCATE_SIZE_ZERO(1, sizeof(*tp)); + tp = SKA_ALLOC_BYTES_ZEROED(sizeof(*tp)); tp->threadCount = num; pthread_mutex_init(&(tp->workMutex), NULL); @@ -137,7 +137,7 @@ void ska_tpool_destroy(SkaThreadPool* tp) { pthread_cond_destroy(&(tp->workCond)); pthread_cond_destroy(&(tp->workingCond)); - SKA_MEM_FREE(tp); + SKA_FREE(tp); } bool ska_tpool_add_work(SkaThreadPool* tp, SkaThreadFunc func, void* arg) { From 2f0ac450189dda99d918852d396ae1c63bc6e4ae Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Sat, 19 Oct 2024 21:10:11 -0400 Subject: [PATCH 30/55] Updates. --- CMakeLists.txt | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index b79e997..9f22101 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -36,4 +36,12 @@ if (SK_IS_MAIN) # Create seika test exe add_executable(seika_test test/test.c) target_link_libraries(seika_test seika unity) + # Copy directories over that are needed to test + if (NOT IS_CI_BUILD) + add_custom_command(TARGET seika_test POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_directory + ${PROJECT_SOURCE_DIR}/test + $/test + ) + endif() endif() From ebb2ba030b1424bf3da5a7c7a40b997300cfe6ae Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Sun, 20 Oct 2024 10:08:11 -0400 Subject: [PATCH 31/55] Update. --- Dependencies.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Dependencies.cmake b/Dependencies.cmake index 1f7f622..287e113 100644 --- a/Dependencies.cmake +++ b/Dependencies.cmake @@ -36,7 +36,7 @@ if (NOT TARGET unity) FetchContent_MakeAvailable(unity_content) endif() -if (SEIKA_INPUT) +if (SEIKA_INPUT OR SEIKA_RENDERING) # https://github.com/libsdl-org/SDL if (NOT TARGET SDL3::SDL3-static) set(SDL_STATIC ${SEIKA_STATIC_LIB}) From 237c1774a40660b49ee07467ffa63b965d193444 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Sun, 20 Oct 2024 13:08:19 -0400 Subject: [PATCH 32/55] Updates. --- seika/event.c | 47 ++++++++++++++++++ seika/event.h | 31 ++++++++++++ test/test.c | 129 +++++++++++++++++++++++++++++++++++++++++++++++++- 3 files changed, 206 insertions(+), 1 deletion(-) create mode 100644 seika/event.c create mode 100644 seika/event.h diff --git a/seika/event.c b/seika/event.c new file mode 100644 index 0000000..8603a2b --- /dev/null +++ b/seika/event.c @@ -0,0 +1,47 @@ +#include "event.h" + +#include "seika/memory.h" +#include "seika/assert.h" +#include "seika/data_structures/array_utils.h" + +//--- Observer ---// +SkaObserver* ska_observer_new(SkaObserverOnNotify onNotifyFunc) { + SKA_ASSERT(onNotifyFunc != NULL); + SkaObserver* observer = SKA_ALLOC(SkaObserver); + observer->on_notify = onNotifyFunc; + return observer; +} + +void ska_observer_delete(SkaObserver* observer) { + SKA_FREE(observer); +} + +//--- Event ---// +SkaEvent* ska_event_new() { + SkaEvent* event = SKA_ALLOC(SkaEvent); + event->observerCount = 0; + return event; +} + +void ska_event_delete(SkaEvent* event) { + SKA_FREE(event); +} + +bool ska_event_register_observer(SkaEvent* event, SkaObserver* observer) { + SKA_ASSERT(event != NULL); + SKA_ASSERT(observer != NULL); + SKA_ASSERT_FMT(event->observerCount + 1 < SKA_MAX_OBSERVERS, "Reached max observer count, consider increasing 'SKA_MAX_OBSERVERS'!"); + event->observers[event->observerCount++] = observer; + return true; +} + +bool ska_event_unregister_observer(SkaEvent* event, SkaObserver* observer) { + SKA_ARRAY_UTILS_REMOVE_ARRAY_ITEM(event->observers, event->observerCount, observer, NULL); + return true; +} + +void ska_event_notify_observers(SkaEvent* event, SkaSubjectNotifyPayload* payload) { + for (usize i = 0; i < event->observerCount; i++) { + event->observers[i]->on_notify(payload); + } +} diff --git a/seika/event.h b/seika/event.h new file mode 100644 index 0000000..54b7ca4 --- /dev/null +++ b/seika/event.h @@ -0,0 +1,31 @@ +#pragma once + +#include "defines.h" + +#define SKA_MAX_OBSERVERS 8 + +typedef struct SkaSubjectNotifyPayload { + void* data; // Primary data, be sure to cast properly +} SkaSubjectNotifyPayload; + +typedef void (*SkaObserverOnNotify)(SkaSubjectNotifyPayload*); + +// An observer that can subscribe to a subject +typedef struct SkaObserver { + SkaObserverOnNotify on_notify; +} SkaObserver; + +SkaObserver* ska_observer_new(SkaObserverOnNotify onNotifyFunc); +void ska_observer_delete(SkaObserver* observer); + +// A subscribable event +typedef struct SkaEvent { + usize observerCount; + SkaObserver* observers[SKA_MAX_OBSERVERS]; +} SkaEvent; + +SkaEvent* ska_event_new(); +void ska_event_delete(SkaEvent* event); +bool ska_event_register_observer(SkaEvent* event, SkaObserver* observer); +bool ska_event_unregister_observer(SkaEvent* event, SkaObserver* observer); +void ska_event_notify_observers(SkaEvent* event, SkaSubjectNotifyPayload* payload); diff --git a/test/test.c b/test/test.c index f8546e0..88b2ac0 100644 --- a/test/test.c +++ b/test/test.c @@ -2,12 +2,15 @@ #include #include "seika/memory.h" +#include "seika/event.h" #include "seika/asset/asset_file_loader.h" #include "seika/data_structures/array2d.h" #include "seika/data_structures/array_list.h" #include "seika/data_structures/id_queue.h" #include "seika/data_structures/spatial_hash_map.h" -#include "seika/math/math.h" +#include "seika/math/curve_float.h" +#include "seika/rendering/shader/shader_instance.h" +#include "seika/rendering/shader/shader_file_parser.h" #if SKA_ECS #include "seika/ecs/ecs.h" @@ -30,7 +33,12 @@ void seika_hash_map_test(void); void seika_spatial_hash_map_test(void); void seika_array2d_test(void); void seika_id_queue_test(void); + void seika_asset_file_loader_test(void); +void seika_observer_test(void); +void seika_curve_float_test(void); +void seika_shader_instance_test(void); +void seika_shader_file_parser_test(void); #if SKA_ECS void seika_ecs_test(void); @@ -49,6 +57,10 @@ int32 main(int32 argv, char** args) { RUN_TEST(seika_array2d_test); RUN_TEST(seika_id_queue_test); RUN_TEST(seika_asset_file_loader_test); + RUN_TEST(seika_observer_test); + RUN_TEST(seika_curve_float_test); + RUN_TEST(seika_shader_instance_test); + RUN_TEST(seika_shader_file_parser_test); #if SKA_ECS RUN_TEST(seika_ecs_test); #endif @@ -268,6 +280,121 @@ void seika_asset_file_loader_test(void) { ska_asset_file_loader_finalize(); } +//--- Observer Test ---// + +static bool hasObserved = false; + +void observer_func1(SkaSubjectNotifyPayload* payload) { + hasObserved = true; +} + +void observer_func2(SkaSubjectNotifyPayload* payload) { + const int dataValue = *(int*) payload->data; + if (dataValue == 3) { + hasObserved = true; + } +} + +void seika_observer_test(void) { + SkaEvent* event = ska_event_new(); + // Test 1 - Simple test with passing a NULL payload + SkaObserver* observer = ska_observer_new(observer_func1); + ska_event_register_observer(event, observer); + TEST_ASSERT_EQUAL_INT(1, event->observerCount); + ska_event_notify_observers(event, NULL); + TEST_ASSERT(hasObserved); + ska_event_unregister_observer(event, observer); + TEST_ASSERT_EQUAL_INT(0, event->observerCount); + hasObserved = false; + + // Test 2 - A slightly more complicated example filling out the payload + ska_observer_delete(observer); + observer = ska_observer_new(observer_func2); + ska_event_register_observer(event, observer); + int dataValue = 3; + ska_event_notify_observers(event, &(SkaSubjectNotifyPayload) { + .data = &dataValue + }); + TEST_ASSERT(hasObserved); + + // Clean up + ska_event_delete(event); + ska_observer_delete(observer); +} + +void seika_curve_float_test(void) { + SkaCurveFloat curve = { .controlPointCount = 0 }; + SkaCurveControlPoint point1 = { .x = 0.0, .y = 0.0, .tangentIn = 0.0, .tangentOut = 0.0 }; + ska_curve_float_add_control_point(&curve, point1); + TEST_ASSERT_EQUAL_UINT(1, curve.controlPointCount); + TEST_ASSERT_EQUAL_DOUBLE(0.0, ska_curve_float_eval(&curve, 1.0)); + SkaCurveControlPoint point2 = { .x = 1.0, .y = 1.0, .tangentIn = 0.0, .tangentOut = 0.0 }; + ska_curve_float_add_control_point(&curve, point2); + TEST_ASSERT_EQUAL_DOUBLE(0.0, ska_curve_float_eval(&curve, 0.0)); + TEST_ASSERT_EQUAL_DOUBLE(0.5, ska_curve_float_eval(&curve, 0.5)); + TEST_ASSERT_EQUAL_DOUBLE(1.0, ska_curve_float_eval(&curve, 1.0)); + ska_curve_float_remove_control_point(&curve, point2.x, point2.y); + TEST_ASSERT_EQUAL_UINT(1, curve.controlPointCount); + + // TODO: Write performance tests +// SE_PROFILE_CODE( +// for (int32 i = 0; i < 10000000; i++) {} +// ) +// +// f64 cpu_time_used; +// SE_PROFILE_CODE_WITH_VAR(cpu_time_used, for (int32 i = 0; i < 10000000; i++) {}) +// printf("Time taken: %f seconds\n", cpu_time_used); +} + +void seika_shader_instance_test(void) { + // Shader instance param tests + SkaShaderInstance shaderInstance = { .shader = NULL, .paramMap = ska_string_hash_map_create_default_capacity() }; + + ska_shader_instance_param_create_bool(&shaderInstance, "is_active", false); + TEST_ASSERT_FALSE(ska_shader_instance_param_get_bool(&shaderInstance, "is_active")); + ska_shader_instance_param_update_bool(&shaderInstance, "is_active", true); + TEST_ASSERT_TRUE(ska_shader_instance_param_get_bool(&shaderInstance, "is_active")); + + // Clean up + SKA_STRING_HASH_MAP_FOR_EACH(shaderInstance.paramMap, iter) { + SkaStringHashMapNode* node = iter.pair; + SkaShaderParam* param = (SkaShaderParam*) node->value; + SKA_FREE(param->name); + } + ska_string_hash_map_destroy(shaderInstance.paramMap); +} + +void seika_shader_file_parser_test(void) { + char shader[] = + "shader_type screen;\n" + "\n" + "uniform float time;\n" + "uniform vec2 size;\n" + "uniform float brightness = 1.0f;\n" + "uniform int spriteCount = 1;\n" + "\n" + "vec3 testFunc() {\n" + " return vec3(1.0f);\n" + "}\n" + "\n" + "void vertex() {\n" + " VERTEX.x += 0.1f;" + "}\n" + "\n" + "void fragment() {\n" + " COLOR *= brightness;\n" + "}\n" + "\n"; + SkaShaderFileParseResult result = ska_shader_file_parser_parse_shader(shader); + // Shouldn't be an error message + const bool hasErrorMessage = strlen(result.errorMessage) > 0; + if (hasErrorMessage) { + printf("Shader parse error = '%s'\n", result.errorMessage); + } + TEST_ASSERT_FALSE(hasErrorMessage); + ska_shader_file_parse_clear_parse_result(&result); +} + #if SKA_ECS typedef struct TestValueComponent { int32 value; From b2843782ca5b0819d2b05d5633383d36bdcb3ede Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Sun, 20 Oct 2024 13:31:53 -0400 Subject: [PATCH 33/55] Clean. --- test/test.c | 1 - 1 file changed, 1 deletion(-) diff --git a/test/test.c b/test/test.c index 88b2ac0..951ceb9 100644 --- a/test/test.c +++ b/test/test.c @@ -120,7 +120,6 @@ void seika_id_queue_test(void) { TEST_ASSERT_TRUE(ska_id_queue_is_empty(idQueue)); - // ska_id_queue_enqueue(idQueue, 4); ska_id_queue_enqueue(idQueue, 6); ska_id_queue_enqueue(idQueue, 5); From b8c5e5857e8a35d955c8ce463f25d7fbb24b44b8 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Sun, 20 Oct 2024 13:32:31 -0400 Subject: [PATCH 34/55] Clean. --- test/old_test.c | 558 ------------------------------------------------ 1 file changed, 558 deletions(-) delete mode 100644 test/old_test.c diff --git a/test/old_test.c b/test/old_test.c deleted file mode 100644 index 2d09753..0000000 --- a/test/old_test.c +++ /dev/null @@ -1,558 +0,0 @@ -#include -#include - -#include "seika/memory.h" -#include "seika/event.h" -#include "seika/input/input.h" -#include "seika/data_structures/hash_map.h" -#include "seika/data_structures/spatial_hash_map.h" -#include "seika/data_structures/array2d.h" -#include "seika/data_structures/linked_list.h" -#include "seika/ecs/ec_system.h" -#include "seika/ecs/ecs.h" -#include "seika/math/curve_float.h" -#include "seika/asset/asset_file_loader.h" -#include "seika/rendering/shader/shader_instance.h" -#include "seika/rendering/shader/shader_file_parser.h" - -#define RESOURCES_PATH "test/resources" -#define RESOURCES_PACK_PATH "test/resources/test.pck" - -void setUp(void) {} -void tearDown(void) {} - -void seika_input_test(void); -void seika_hash_map_test(void); -void seika_spatial_hash_map_test(void); -void seika_linked_list_test(void); -void seika_array2d_test(void); - -void seika_asset_file_loader_test(void); -void seika_observer_test(void); -void seika_curve_float_test(void); -void seika_shader_instance_test(void); -void seika_shader_file_parser_test(void); -void seika_ecs_test(void); - -int32 main(int32 argv, char** args) { - UNITY_BEGIN(); - RUN_TEST(seika_input_test); - RUN_TEST(seika_hash_map_test); - RUN_TEST(seika_spatial_hash_map_test); - RUN_TEST(seika_linked_list_test); - RUN_TEST(seika_array2d_test); - RUN_TEST(seika_asset_file_loader_test); - RUN_TEST(seika_observer_test); - RUN_TEST(seika_curve_float_test); - RUN_TEST(seika_shader_instance_test); - RUN_TEST(seika_shader_file_parser_test); - RUN_TEST(seika_ecs_test); - return UNITY_END(); -} - -void seika_input_test(void) { - TEST_MESSAGE("Testing 'for each' and checking input type"); - SKA_INPUT_KEY_GAMEPAD_FOR_EACH(key) { - TEST_ASSERT_TRUE(ska_input_is_gamepad_key(key)); - } - SKA_INPUT_KEY_KEYBOARD_FOR_EACH(key) { - TEST_ASSERT_TRUE(ska_input_is_keyboard_key(key)); - } - SKA_INPUT_KEY_MOUSE_FOR_EACH(key) { - TEST_ASSERT_TRUE(ska_input_is_mouse_key(key)); - } - - const char* backspaceKeyName = ska_input_key_to_string(SkaInputKey_KEYBOARD_BACKSPACE); - const SkaInputKey backSpaceKey = ska_input_string_to_key(backspaceKeyName); - TEST_ASSERT_EQUAL_STRING("Backspace", backspaceKeyName); - TEST_ASSERT_EQUAL_INT(SkaInputKey_KEYBOARD_BACKSPACE, backSpaceKey); - - TEST_MESSAGE("Testing events"); - ska_input_register_input_event3(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_BACKSPACE, SkaInputTriggerType_PRESSED); - TEST_ASSERT_TRUE(ska_input_is_key_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_TRUE(ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_key_just_released(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - - ska_input_register_input_event3(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_BACKSPACE, SkaInputTriggerType_PRESSED); - TEST_ASSERT_TRUE(ska_input_is_key_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_key_just_released(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - - ska_input_register_input_event3(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_BACKSPACE, SkaInputTriggerType_RELEASED); - TEST_ASSERT_FALSE(ska_input_is_key_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_TRUE(ska_input_is_key_just_released(SkaInputKey_KEYBOARD_BACKSPACE, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - - TEST_MESSAGE("Testing input get axis input"); - ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y, SkaInputTriggerType_AXIS_IN_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, -0.5f); - const SkaVector2 firstAxisInput = ska_input_get_axis_input(SkaInputAxis_LEFT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); - TEST_ASSERT_EQUAL_FLOAT(0.0f, firstAxisInput.x); - TEST_ASSERT_EQUAL_FLOAT(-0.5f, firstAxisInput.y); - - ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X, SkaInputTriggerType_AXIS_IN_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.25f); - const SkaVector2 secondAxisInput = ska_input_get_axis_input(SkaInputAxis_LEFT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); - TEST_ASSERT_EQUAL_FLOAT(0.25f, secondAxisInput.x); - TEST_ASSERT_EQUAL_FLOAT(-0.5f, secondAxisInput.y); - - ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X, SkaInputTriggerType_AXIS_STOPPED_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.25f); - ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y, SkaInputTriggerType_AXIS_STOPPED_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.25f); - const SkaVector2 thirdAxisInput = ska_input_get_axis_input(SkaInputAxis_LEFT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); - TEST_ASSERT_EQUAL_FLOAT(0.0f, thirdAxisInput.x); - TEST_ASSERT_EQUAL_FLOAT(0.0f, thirdAxisInput.y); - - ska_input_register_input_event(SkaInputSourceType_GAMEPAD, SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X, SkaInputTriggerType_AXIS_IN_MOTION, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 1.0f); - const SkaVector2 fourthAxisInput = ska_input_get_axis_input(SkaInputAxis_RIGHT, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); - TEST_ASSERT_EQUAL_FLOAT(1.0f, fourthAxisInput.x); - TEST_ASSERT_EQUAL_FLOAT(0.0f, fourthAxisInput.y); - - TEST_MESSAGE("Testing input actions"); - SkaInputActionHandle jumpActionHandle = ska_input_add_input_action( - "jump", - (SkaInputActionValue[]){ { .key = SkaInputKey_KEYBOARD_SPACE, .strengthThreshold = 0.5f }, { .key = SkaInputKey_KEYBOARD_RETURN, .strengthThreshold = 0.5f }, { SkaInputKey_INVALID } }, - SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX - ); - TEST_ASSERT_NOT_EQUAL_UINT32(SKA_INPUT_INVALID_INPUT_ACTION_HANDLE, jumpActionHandle); - jumpActionHandle = ska_input_find_input_action_handle("jump", SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); - TEST_ASSERT_NOT_EQUAL_UINT32(SKA_INPUT_INVALID_INPUT_ACTION_HANDLE, jumpActionHandle); - - ska_input_register_input_event(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_RETURN, SkaInputTriggerType_PRESSED, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.0f); - TEST_ASSERT_TRUE(ska_input_is_input_action_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_TRUE(ska_input_is_input_action_just_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_input_action_just_released(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_EQUAL_FLOAT(1.0f, ska_input_get_input_action_strength(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - - ska_input_new_frame(); - TEST_ASSERT_TRUE(ska_input_is_input_action_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_input_action_just_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_input_action_just_released(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - - ska_input_register_input_event(SkaInputSourceType_KEYBOARD, SkaInputKey_KEYBOARD_RETURN, SkaInputTriggerType_RELEASED, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, 0.0f); - TEST_ASSERT_FALSE(ska_input_is_input_action_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_FALSE(ska_input_is_input_action_just_pressed(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - TEST_ASSERT_TRUE(ska_input_is_input_action_just_released(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); - - ska_input_remove_input_action(jumpActionHandle, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); - TEST_ASSERT_EQUAL_UINT32(SKA_INPUT_INVALID_INPUT_ACTION_HANDLE, ska_input_find_input_action_handle("jump", SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX)); -} - -void seika_hash_map_test(void) { - SkaHashMap* hashMap = ska_hash_map_create(sizeof(int32), sizeof(int32), SKA_HASH_MAP_MIN_CAPACITY); - TEST_ASSERT_NOT_NULL(hashMap); - - int32 key1 = 0; - int32 value1 = 11; - ska_hash_map_add(hashMap, &key1, &value1); - TEST_ASSERT_EQUAL_INT(1, hashMap->size); - int32 returnedValue1 = *(int32*) ska_hash_map_get(hashMap, &key1); - TEST_ASSERT_EQUAL_INT(value1, returnedValue1); - - int32 key2 = 1; - int32 value2 = 22; - ska_hash_map_add(hashMap, &key2, &value2); - TEST_ASSERT_EQUAL_INT(2, hashMap->size); - - // Iterator test - int32 iterCount = 0; - for (SkaHashMapIterator iterator = ska_hash_map_iter_create(hashMap); ska_hash_map_iter_is_valid(hashMap, &iterator); ska_hash_map_iter_advance(hashMap, &iterator)) { - iterCount++; - } - TEST_ASSERT_EQUAL_INT(2, iterCount); - // Iter Macro test - iterCount = 0; - SKA_HASH_MAP_FOR_EACH(hashMap, iter) { - iterCount++; - } - TEST_ASSERT_EQUAL_INT(2, iterCount); - - ska_hash_map_destroy(hashMap); -} - -void seika_spatial_hash_map_test(void) { - const int32 maxSpriteSize = 32; - SkaSpatialHashMap* spatialHashMap = ska_spatial_hash_map_create(maxSpriteSize * 2); - TEST_ASSERT_NOT_NULL(spatialHashMap); - - // Create two entities and insert them into hash map - const uint32 entity = 1; - SkaSpatialHashMapGridSpacesHandle* handle = ska_spatial_hash_map_insert_or_update(spatialHashMap, entity, &(SkaRect2) { - 0.0f, 0.0f, 32.0f, 32.0f - }); - TEST_ASSERT_EQUAL(handle, ska_spatial_hash_map_get(spatialHashMap, entity)); - - const uint32 entityTwo = 2; - SkaSpatialHashMapGridSpacesHandle* handleTwo = ska_spatial_hash_map_insert_or_update(spatialHashMap, entityTwo, &(SkaRect2) { - 16.0f, 16.0f, 48.0f, 48.0f - }); - TEST_ASSERT_EQUAL(handleTwo, ska_spatial_hash_map_get(spatialHashMap, entityTwo)); - - // An entity that should not be collided with - const uint32 entityNotCollided = 3; - ska_spatial_hash_map_insert_or_update(spatialHashMap, entityNotCollided, &(SkaRect2) { - 64.0f, 64.0f, 96.0f, 96.0f - }); - - // Test collision result to make sure the two entities collide - const SkaSpatialHashMapCollisionResult collisionResult = ska_spatial_hash_map_compute_collision(spatialHashMap, entity); - TEST_ASSERT_EQUAL_INT(1, collisionResult.collisionCount); - - if (collisionResult.collisionCount > 0) { - TEST_ASSERT_EQUAL_INT(2, collisionResult.collisions[0]); - } - - ska_spatial_hash_map_remove(spatialHashMap, entity); - TEST_ASSERT_NULL(ska_spatial_hash_map_get(spatialHashMap, entity)); - ska_spatial_hash_map_remove(spatialHashMap, entityTwo); - TEST_ASSERT_NULL(ska_spatial_hash_map_get(spatialHashMap, entityTwo)); - - ska_spatial_hash_map_destroy(spatialHashMap); -} - -static bool linked_list_test_sort(void* a, void* b) { - int numA = (int) *(int*) a; - int numB = (int) *(int*) b; - return numA > numB; -} - -void seika_linked_list_test(void) { - SkaLinkedList* list = ska_linked_list_create(sizeof(int32)); - // Test prepend - int32 num1 = 9; - int32 num2 = 7; - ska_linked_list_prepend(list, &num1); - const int32 returnedNum = (int32) *(int32*) ska_linked_list_get_front(list); - TEST_ASSERT_EQUAL_INT(1, list->size); - TEST_ASSERT_EQUAL_INT(num1, returnedNum); - ska_linked_list_prepend(list, &num2); - TEST_ASSERT_EQUAL_INT(2, list->size); - ska_linked_list_remove(list, &num1); - TEST_ASSERT_EQUAL_INT(1, list->size); - int32* returnedNum2 = (int32*) ska_linked_list_pop_front(list); - TEST_ASSERT_EQUAL_INT(7, *returnedNum2); - TEST_ASSERT_TRUE(ska_linked_list_is_empty(list)); - SKA_MEM_FREE(returnedNum2); - - int32 numbers[5]; - for (int32 i = 0; i < 5; i++) { - numbers[i] = i; - ska_linked_list_append(list, &i); - } - TEST_ASSERT_EQUAL_INT(5, list->size); - - // For each loop test - SkaLinkedListNode* node = NULL; - int32 loopIndex = 0; - SKA_LINKED_LIST_FOR_EACH(list, node) { - const int32 indexNum = (int32)*(int32*)node->value; - TEST_ASSERT_EQUAL_INT(indexNum, numbers[loopIndex]); - loopIndex++; - } - - const int32 indexThreeNum = (int32)*(int32*)ska_linked_list_get(list, 3); - TEST_ASSERT_EQUAL_INT(3, indexThreeNum); - - // Insert Test - int32 insertNum1 = 10; - int32 insertNum2 = 20; - ska_linked_list_insert(list, &insertNum1, 3); - TEST_ASSERT_EQUAL_INT(6, list->size); - ska_linked_list_insert(list, &insertNum2, 1); - TEST_ASSERT_EQUAL_INT(7, list->size); - const int32 insertNumThree = (int32)*(int32*)ska_linked_list_get(list, 3); - TEST_ASSERT_EQUAL_INT(10, insertNumThree); - const int32 insertNumOne = (int32)*(int32*)ska_linked_list_get(list, 1); - TEST_ASSERT_EQUAL_INT(20, insertNumOne); - - ska_linked_list_sort(list, linked_list_test_sort); - const int32 smallestNum = (int32)*(int32*)ska_linked_list_get_front(list); - const int32 highestNum = (int32)*(int32*)ska_linked_list_get_back(list); - TEST_ASSERT_EQUAL_INT(0, smallestNum); - TEST_ASSERT_EQUAL_INT(20, highestNum); - - // Clear test - ska_linked_list_clear(list); - TEST_ASSERT_EQUAL_INT(0, list->size); - - ska_linked_list_destroy(list); -} - -void seika_array2d_test(void) { - typedef struct TestArrayStruct { - int value; - } TestArrayStruct; - - SkaArray2D* array2D = ska_array2d_create(5, 5, sizeof(TestArrayStruct)); - - TestArrayStruct* struct0_3 = (TestArrayStruct*)ska_array2d_get(array2D, 0, 3); - TEST_ASSERT_NOT_NULL(struct0_3); - TEST_ASSERT_EQUAL_INT(0, struct0_3->value); - - struct0_3->value = 5; - const TestArrayStruct* struct0_3Again = (TestArrayStruct*)ska_array2d_get(array2D, 0, 3); - TEST_ASSERT_EQUAL_INT(5, struct0_3Again->value); - - TestArrayStruct* struct4_2 = (TestArrayStruct*)ska_array2d_get(array2D, 4, 2); - TEST_ASSERT_NOT_NULL(struct4_2); - TEST_ASSERT_EQUAL_INT(0, struct4_2->value); - bool wasSetSuccessful = ska_array2d_set(array2D, 4, 2, &(TestArrayStruct){ .value = 1000 }); - TEST_ASSERT_TRUE(wasSetSuccessful); - TEST_ASSERT_EQUAL_INT(1000, struct4_2->value); - wasSetSuccessful = false; - - TestArrayStruct* struct7_9 = (TestArrayStruct*)ska_array2d_get(array2D, 7, 7); - TEST_ASSERT_NULL(struct7_9); - wasSetSuccessful = ska_array2d_set(array2D, 7, 9, &(TestArrayStruct){ .value = 1000 }); - TEST_ASSERT_FALSE(wasSetSuccessful); - ska_array2d_resize(array2D, 10, 10); - struct7_9 = (TestArrayStruct*)ska_array2d_get(array2D, 7, 7); - TEST_ASSERT_NOT_NULL(struct7_9); - // Test old struct values - const TestArrayStruct* struct0_3Again2 = (TestArrayStruct*)ska_array2d_get(array2D, 0, 3); - const TestArrayStruct* struct4_2Again = (TestArrayStruct*)ska_array2d_get(array2D, 4, 2); - TEST_ASSERT_EQUAL_INT(5, struct0_3Again2->value); - TEST_ASSERT_EQUAL_INT(1000, struct4_2Again->value); - - ska_array2d_resize(array2D, 4, 4); - TEST_ASSERT_NULL(ska_array2d_get(array2D, 7, 7)); - const TestArrayStruct* struct0_3Again3 = (TestArrayStruct*)ska_array2d_get(array2D, 0, 3); - TEST_ASSERT_NOT_NULL(struct0_3Again3); - TEST_ASSERT_EQUAL_INT(5, struct0_3Again3->value); - - ska_array2d_reset(array2D); - const TestArrayStruct* struct0_3Again4 = (TestArrayStruct*)ska_array2d_get(array2D, 0, 3); - TEST_ASSERT_EQUAL_INT(0, struct0_3Again4->value); - ska_array2d_reset_default(array2D, &(TestArrayStruct){ .value = 230 }); - const TestArrayStruct* struct0_3Again5 = (TestArrayStruct*)ska_array2d_get(array2D, 0, 3); - TEST_ASSERT_EQUAL_INT(230, struct0_3Again5->value); - - ska_array2d_destroy(array2D); -} - -void seika_asset_file_loader_test(void) { - ska_asset_file_loader_initialize(); - - ska_asset_file_loader_set_read_mode(SkaAssetFileLoaderReadMode_ARCHIVE); - const bool hasLoaded = ska_asset_file_loader_load_archive("test/resources/test.pck"); - TEST_ASSERT_TRUE(hasLoaded); - - // File exists in archive - SkaArchiveFileAsset existingFileAsset = ska_asset_file_loader_get_asset("test.txt"); - TEST_ASSERT_TRUE(ska_asset_file_loader_is_asset_valid(&existingFileAsset)); - // File doesn't exist - SkaArchiveFileAsset nonExistingFileAsset = ska_asset_file_loader_get_asset("test.png"); - TEST_ASSERT_FALSE(ska_asset_file_loader_is_asset_valid(&nonExistingFileAsset)); - // Test loading from disk - SkaArchiveFileAsset diskAsset = ska_asset_file_loader_load_asset_from_disk("test/resources/test.pck"); - TEST_ASSERT_TRUE(ska_asset_file_loader_is_asset_valid(&diskAsset)); - - ska_asset_file_loader_finalize(); -} - -// Observer Test -static bool hasObserved = false; - -void observer_func1(SkaSubjectNotifyPayload* payload) { - hasObserved = true; -} - -void observer_func2(SkaSubjectNotifyPayload* payload) { - const int dataValue = *(int*) payload->data; - if (dataValue == 3) { - hasObserved = true; - } -} - -void seika_observer_test(void) { - SkaEvent* event = ska_event_new(); - // Test 1 - Simple test with passing a NULL payload - SkaObserver* observer = ska_observer_new(observer_func1); - ska_event_register_observer(event, observer); - TEST_ASSERT_EQUAL_INT(1, event->observerCount); - ska_event_notify_observers(event, NULL); - TEST_ASSERT(hasObserved); - ska_event_unregister_observer(event, observer); - TEST_ASSERT_EQUAL_INT(0, event->observerCount); - hasObserved = false; - - // Test 2 - A slightly more complicated example filling out the payload - ska_observer_delete(observer); - observer = ska_observer_new(observer_func2); - ska_event_register_observer(event, observer); - int dataValue = 3; - ska_event_notify_observers(event, &(SkaSubjectNotifyPayload) { - .data = &dataValue - }); - TEST_ASSERT(hasObserved); - - // Clean up - ska_event_delete(event); - ska_observer_delete(observer); -} - -void seika_curve_float_test(void) { - SkaCurveFloat curve = { .controlPointCount = 0 }; - SkaCurveControlPoint point1 = { .x = 0.0, .y = 0.0, .tangentIn = 0.0, .tangentOut = 0.0 }; - ska_curve_float_add_control_point(&curve, point1); - TEST_ASSERT_EQUAL_UINT(1, curve.controlPointCount); - TEST_ASSERT_EQUAL_DOUBLE(0.0, ska_curve_float_eval(&curve, 1.0)); - SkaCurveControlPoint point2 = { .x = 1.0, .y = 1.0, .tangentIn = 0.0, .tangentOut = 0.0 }; - ska_curve_float_add_control_point(&curve, point2); - TEST_ASSERT_EQUAL_DOUBLE(0.0, ska_curve_float_eval(&curve, 0.0)); - TEST_ASSERT_EQUAL_DOUBLE(0.5, ska_curve_float_eval(&curve, 0.5)); - TEST_ASSERT_EQUAL_DOUBLE(1.0, ska_curve_float_eval(&curve, 1.0)); - ska_curve_float_remove_control_point(&curve, point2.x, point2.y); - TEST_ASSERT_EQUAL_UINT(1, curve.controlPointCount); - - // TODO: Write performance tests -// SE_PROFILE_CODE( -// for (int32 i = 0; i < 10000000; i++) {} -// ) -// -// f64 cpu_time_used; -// SE_PROFILE_CODE_WITH_VAR(cpu_time_used, for (int32 i = 0; i < 10000000; i++) {}) -// printf("Time taken: %f seconds\n", cpu_time_used); -} - -void seika_shader_instance_test(void) { - // Shader instance param tests - SkaShaderInstance shaderInstance = { .shader = NULL, .paramMap = ska_string_hash_map_create_default_capacity() }; - - ska_shader_instance_param_create_bool(&shaderInstance, "is_active", false); - TEST_ASSERT_FALSE(ska_shader_instance_param_get_bool(&shaderInstance, "is_active")); - ska_shader_instance_param_update_bool(&shaderInstance, "is_active", true); - TEST_ASSERT_TRUE(ska_shader_instance_param_get_bool(&shaderInstance, "is_active")); - - // Clean up - SKA_STRING_HASH_MAP_FOR_EACH(shaderInstance.paramMap, iter) { - SkaStringHashMapNode* node = iter.pair; - SkaShaderParam* param = (SkaShaderParam*) node->value; - SKA_MEM_FREE(param->name); - } - ska_string_hash_map_destroy(shaderInstance.paramMap); -} - -void seika_shader_file_parser_test(void) { - char shader[] = - "shader_type screen;\n" - "\n" - "uniform float time;\n" - "uniform vec2 size;\n" - "uniform float brightness = 1.0f;\n" - "uniform int spriteCount = 1;\n" - "\n" - "vec3 testFunc() {\n" - " return vec3(1.0f);\n" - "}\n" - "\n" - "void vertex() {\n" - " VERTEX.x += 0.1f;" - "}\n" - "\n" - "void fragment() {\n" - " COLOR *= brightness;\n" - "}\n" - "\n"; - SkaShaderFileParseResult result = ska_shader_file_parser_parse_shader(shader); - // Shouldn't be an error message - const bool hasErrorMessage = strlen(result.errorMessage) > 0; - if (hasErrorMessage) { - printf("Shader parse error = '%s'\n", result.errorMessage); - } - TEST_ASSERT_FALSE(hasErrorMessage); - ska_shader_file_parse_clear_parse_result(&result); -} - -// ECS TEST -typedef struct TestValueComponent { - int32 value; -} TestValueComponent; - -typedef struct TestTransformComponent { - SkaTransform2D transform2D; -} TestTransformComponent; - -// test ecs callbacks - -static int32 entityRegisteredInTestCount = 0; -void test_ecs_callback_on_entity_registered(SkaECSSystem* system, SkaEntity entity){ - entityRegisteredInTestCount++; -} - -void seika_ecs_test(void) { - ska_ecs_initialize(); - - SKA_ECS_REGISTER_COMPONENT(TestValueComponent); - SKA_ECS_REGISTER_COMPONENT(TestTransformComponent); - - // Test getting component type info - const SkaComponentTypeInfo* valueTypeInfo = SKA_ECS_COMPONENT_TYPE_INFO(TestValueComponent); - TEST_ASSERT_NOT_NULL(valueTypeInfo); - TEST_ASSERT_EQUAL_STRING("TestValueComponent", valueTypeInfo->name); - TEST_ASSERT_EQUAL_INT(1 << 0, valueTypeInfo->type); - TEST_ASSERT_EQUAL_UINT32(0, valueTypeInfo->index); - TEST_ASSERT_EQUAL_size_t(sizeof(TestValueComponent), valueTypeInfo->size); - const SkaComponentTypeInfo* transformTypeInfo = SKA_ECS_COMPONENT_TYPE_INFO(TestTransformComponent); - TEST_ASSERT_NOT_NULL(transformTypeInfo); - TEST_ASSERT_EQUAL_STRING("TestTransformComponent", transformTypeInfo->name); - TEST_ASSERT_EQUAL_INT(1 << 1, transformTypeInfo->type); - TEST_ASSERT_EQUAL_UINT32(1, transformTypeInfo->index); - TEST_ASSERT_EQUAL_size_t(sizeof(TestTransformComponent), transformTypeInfo->size); - - // Test creating ecs system - const SkaEntity testEntity = ska_ecs_entity_create(); - - SkaECSSystem* testValueEcsSystem = SKA_ECS_SYSTEM_CREATE("test value system", TestValueComponent); - testValueEcsSystem->on_entity_registered_func = test_ecs_callback_on_entity_registered; - ska_ecs_system_register(testValueEcsSystem); - - // Test creating with template -#define VALUE_TRANSFORM_SYSTEM_TEMPLATE &(SkaECSSystemTemplate){ \ - .name = "test value transform system", \ - .on_ec_system_register = NULL, \ - .on_ec_system_destroy = NULL, \ - .on_entity_registered_func = test_ecs_callback_on_entity_registered, \ - .on_entity_start_func = NULL, \ - .on_entity_end_func = NULL, \ - .on_entity_unregistered_func = NULL, \ - .on_entity_entered_scene_func = NULL, \ - .render_func = NULL, \ - .pre_update_all_func = NULL, \ - .post_update_all_func = NULL, \ - .update_func = NULL, \ - .fixed_update_func = NULL, \ - .network_callback_func = NULL \ -} - SKA_ECS_SYSTEM_REGISTER_FROM_TEMPLATE(VALUE_TRANSFORM_SYSTEM_TEMPLATE, TestValueComponent, TestTransformComponent); -#undef VALUE_TRANSFORM_SYSTEM_TEMPLATE - - // Test entity id enqueue and dequeue -#define TEST_ENTITY_QUEUE_AMOUNT 1000 - for (SkaEntity entity = 1; entity < TEST_ENTITY_QUEUE_AMOUNT; entity++) { - const SkaEntity newEntity = ska_ecs_entity_create(); - TEST_ASSERT_EQUAL_UINT32(entity, newEntity); - } - TEST_ASSERT_EQUAL_size_t(TEST_ENTITY_QUEUE_AMOUNT, ska_ecs_entity_get_active_count()); - for (SkaEntity entity = 1; entity < TEST_ENTITY_QUEUE_AMOUNT; entity++) { - ska_ecs_entity_return(entity); - } - TEST_ASSERT_EQUAL_size_t(1, ska_ecs_entity_get_active_count()); -#undef TEST_ENTITY_QUEUE_AMOUNT - - // Test getting component - TestValueComponent testComponent = { .value = 10 }; - ska_ecs_component_manager_set_component(testEntity, valueTypeInfo->index, &testComponent); - TestValueComponent* returnedValueComponent = (TestValueComponent*)ska_ecs_component_manager_get_component(testEntity, valueTypeInfo->index); - TEST_ASSERT_NOT_NULL(returnedValueComponent); - TEST_ASSERT_EQUAL_INT(10, returnedValueComponent->value); - TestTransformComponent transformComponent = { .transform2D = { .position = { .x = 10.0f, .y = 20.0f}, .scale = SKA_VECTOR2_ONE, .rotation = 0.0f } }; - ska_ecs_component_manager_set_component(testEntity, transformTypeInfo->index, &transformComponent); - TestTransformComponent* returnedTransformComponent = (TestTransformComponent*)ska_ecs_component_manager_get_component(testEntity, transformTypeInfo->index); - TEST_ASSERT_NOT_NULL(returnedTransformComponent); - TEST_ASSERT_EQUAL_FLOAT(10.0f, returnedTransformComponent->transform2D.position.x); - TEST_ASSERT_EQUAL_FLOAT(20.0f, returnedTransformComponent->transform2D.position.y); - - // Test component events - ska_ecs_system_update_entity_signature_with_systems(testEntity); - TEST_ASSERT_EQUAL_INT(2, entityRegisteredInTestCount); - - ska_ecs_finalize(); -} From 45167937a9450d367df53621878755d0b4f6f2f9 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Sun, 20 Oct 2024 13:34:39 -0400 Subject: [PATCH 35/55] Updates. --- seika/command_line_args_util.c | 83 ++++++++++++++++++++++++++++++++++ seika/command_line_args_util.h | 28 ++++++++++++ 2 files changed, 111 insertions(+) create mode 100644 seika/command_line_args_util.c create mode 100644 seika/command_line_args_util.h diff --git a/seika/command_line_args_util.c b/seika/command_line_args_util.c new file mode 100644 index 0000000..37f9205 --- /dev/null +++ b/seika/command_line_args_util.c @@ -0,0 +1,83 @@ +#include "command_line_args_util.h" + +#include +#include + +#include "seika/data_structures/hash_map_string.h" + +static SkaStringHashMap* ska_cmd_line_args_get_key_to_arg_def_map(SKACmdLineArgDef* argDefs) { + SkaStringHashMap* keyToArgDefMap = ska_string_hash_map_create_default_capacity(); + for (usize i = 0; i < 999999999; i++) { + if (argDefs[i].id == NULL) { + break; + } + + SKACmdLineArgDef* argDef = &argDefs[i]; + for (usize argIndex = 0; argIndex < SKA_COMMAND_LINE_ARGS_KEY_LIMIT; argIndex++) { + const char* argKey = argDef->keys[argIndex]; + if (!argKey) { + break; + } + + ska_string_hash_map_add(keyToArgDefMap, argKey, argDef, sizeof(SKACmdLineArgDef)); + } + } + + return keyToArgDefMap; +} + +SKACmdLineArgKeyResult* ska_cmd_line_args_util_find_or_add_key_result(const SKACmdLineArgDef* argDef, SKACmdLineArgResult* result) { + for (usize i = 0; i < result->keyResultCount; i++) { + SKACmdLineArgKeyResult* keyResult = &result->keyResults[i]; + for (usize j = 0; j < SKA_COMMAND_LINE_ARGS_KEY_LIMIT; j++) { + if (!argDef->keys[j]) { + break; + } + + if (strcmp(keyResult->id, argDef->id) == 0) { + return keyResult; + } + } + } + + // If here, we don't have a key result so add one + SKACmdLineArgKeyResult* keyResult = &result->keyResults[result->keyResultCount++]; + keyResult->id = argDef->id; + + return keyResult; +} + +SKACmdLineArgResult ska_cmd_line_args_util_parse(int32 argv, char** args, SKACmdLineArgDef* argDefs) { + SKACmdLineArgResult result = (SKACmdLineArgResult){0}; + SkaStringHashMap* keyToArgDefMap = ska_cmd_line_args_get_key_to_arg_def_map(argDefs); + + for (int32 i = 0; i < argv; i++) { + const char* arg = args[i]; + const SKACmdLineArgDef* argDef = (SKACmdLineArgDef*)ska_string_hash_map_find(keyToArgDefMap, arg); + if (argDef) { + SKACmdLineArgKeyResult* keyResult = ska_cmd_line_args_util_find_or_add_key_result(argDef, &result); + if (argDef->expectsValue) { + const int32 nextArgIndex = i + 1; + if (nextArgIndex < argv) { + keyResult->values[keyResult->valueCount++] = args[nextArgIndex]; + } + } + } + } + + ska_string_hash_map_destroy(keyToArgDefMap); + + return result; +} + +void ska_cmd_line_args_util_print_results(const SKACmdLineArgResult* result) { + for (usize i = 0; i < result->keyResultCount; i++) { + const SKACmdLineArgKeyResult* keyResult = &result->keyResults[i]; + printf("---------------------------------------------------------------\n"); + printf("Key Id: '%s'\n", keyResult->id); + for (usize valueIndex = 0; valueIndex < keyResult->valueCount; valueIndex++) { + printf("Value: '%s'\n", keyResult->values[valueIndex]); + } + printf("---------------------------------------------------------------\n"); + } +} diff --git a/seika/command_line_args_util.h b/seika/command_line_args_util.h new file mode 100644 index 0000000..720a3ad --- /dev/null +++ b/seika/command_line_args_util.h @@ -0,0 +1,28 @@ +#pragma once + +#include "seika/defines.h" + +#define SKA_COMMAND_LINE_ARGS_KEY_LIMIT 8 +#define SKA_COMMAND_LINE_ARGS_RETURN_LIMIT 8 +#define SKA_COMMAND_LINE_ARGS_RETURN_VALUES_LIMIT 8 + +typedef struct SKACmdLineArgDef { + const char* id; + const char* description; + bool expectsValue; + const char* keys[SKA_COMMAND_LINE_ARGS_KEY_LIMIT]; +} SKACmdLineArgDef; + +typedef struct SKACmdLineArgKeyResult { + const char* id; + const char* values[SKA_COMMAND_LINE_ARGS_RETURN_VALUES_LIMIT]; + usize valueCount; +} SKACmdLineArgKeyResult; + +typedef struct SKACmdLineArgResult { + SKACmdLineArgKeyResult keyResults[SKA_COMMAND_LINE_ARGS_RETURN_LIMIT]; + usize keyResultCount; +} SKACmdLineArgResult; + +SKACmdLineArgResult ska_cmd_line_args_util_parse(int32 argv, char** args, SKACmdLineArgDef* argDefs); +void ska_cmd_line_args_util_print_results(const SKACmdLineArgResult* result); From 339ba70cb613e420d4771b103e769173966b2df7 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Sun, 20 Oct 2024 18:26:32 -0400 Subject: [PATCH 36/55] Update. --- seika/input/input.c | 24 ++++++++++++++++++++++++ seika/input/input.h | 3 +++ 2 files changed, 27 insertions(+) diff --git a/seika/input/input.c b/seika/input/input.c index 42d86aa..cd1d577 100644 --- a/seika/input/input.c +++ b/seika/input/input.c @@ -1,6 +1,9 @@ #if SKA_INPUT +#include + #include "input.h" +#include "sdl_input.h" #include "seika/string.h" #include "seika/assert.h" #include "seika/memory.h" @@ -48,11 +51,32 @@ typedef struct SkaInputState { static SkaInputState inputState = DEFAULT_INPUT_STATE; static SkaMouse globalMouse = {0}; +static bool isInputActive = false; static SkaInputKey get_key_from_2d_axis_key(SkaInputKey axis2DKey, SkaAxisInputValues* axisInputValues, f32 axisValue); static void set_prev_input_axis_value(SkaInputKey key, SkaAxisInputValues* axisInputValues, f32 axisValue); static void update_axis_key_state(SkaInputKey key, SkaInputInteractionStatus interactionStatus, f32 axisValue, SkaInputDeviceIndex deviceIndex); +bool ska_input_initialize() { + SKA_ASSERT(!isInputActive); + if (SDL_InitSubSystem( SDL_INIT_JOYSTICK | SDL_INIT_GAMEPAD) != 0) { + return false; + } + + if (!ska_sdl_load_gamepad_mappings()) { + return false; + } + + isInputActive = true; + return true; +} + +void ska_input_finalize() { + SKA_ASSERT(isInputActive); + SDL_QuitSubSystem(SDL_INIT_JOYSTICK | SDL_INIT_GAMEPAD); + isInputActive = false; +} + const char* ska_input_key_to_string(SkaInputKey key) { static const char* keyNames[SkaInputKey_NUMBER_OF_KEYS] = { [SkaInputKey_INVALID] = "Invalid", diff --git a/seika/input/input.h b/seika/input/input.h index 64336a1..a1ef0cc 100644 --- a/seika/input/input.h +++ b/seika/input/input.h @@ -252,6 +252,9 @@ typedef struct SkaInputAction { usize actionValuesCount; } SkaInputAction; +bool ska_input_initialize(); +void ska_input_finalize(); + const char* ska_input_key_to_string(SkaInputKey key); SkaInputKey ska_input_string_to_key(const char* keyName); From 3e54b2f39aad71b3132a08a9be2e9c1589ceff4f Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Sun, 20 Oct 2024 19:16:18 -0400 Subject: [PATCH 37/55] Clean. --- seika/input/input.c | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/seika/input/input.c b/seika/input/input.c index cd1d577..884ffbc 100644 --- a/seika/input/input.c +++ b/seika/input/input.c @@ -59,10 +59,18 @@ static void update_axis_key_state(SkaInputKey key, SkaInputInteractionStatus int bool ska_input_initialize() { SKA_ASSERT(!isInputActive); - if (SDL_InitSubSystem( SDL_INIT_JOYSTICK | SDL_INIT_GAMEPAD) != 0) { - return false; + const bool isSDLInitialized = SDL_WasInit(0) != 0; + if (isSDLInitialized) { + if (SDL_InitSubSystem( SDL_INIT_JOYSTICK | SDL_INIT_GAMEPAD) != 0) { + return false; + } + } else { + if (SDL_Init( SDL_INIT_JOYSTICK | SDL_INIT_GAMEPAD) != 0) { + return false; + } } + if (!ska_sdl_load_gamepad_mappings()) { return false; } @@ -74,6 +82,11 @@ bool ska_input_initialize() { void ska_input_finalize() { SKA_ASSERT(isInputActive); SDL_QuitSubSystem(SDL_INIT_JOYSTICK | SDL_INIT_GAMEPAD); + const bool subsystemsStillInitialized = SDL_WasInit(0) != 0; + if (!subsystemsStillInitialized) { + SDL_Quit(); + } + isInputActive = false; } From b277390f656f927455e77a1d32cac8c0b7629108 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Sun, 20 Oct 2024 19:24:10 -0400 Subject: [PATCH 38/55] Clean. --- CMakeLists.txt | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 9f22101..27360d3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -25,6 +25,14 @@ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) include(Dependencies.cmake) add_subdirectory(seika) +# Apply the compile definitions to the `seika` target +target_compile_definitions(seika + PUBLIC + SKA_ECS=$,1,0> + SKA_INPUT=$,1,0> + SKA_RENDERING=$,1,0> + SKA_AUDIO=$,1,0> +) if ("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}") set(SK_IS_MAIN TRUE) From 39e708fa4b5a4279415521b93b1601f5c3e4448b Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Sun, 20 Oct 2024 19:27:51 -0400 Subject: [PATCH 39/55] Clean up. --- CMakeLists.txt | 6 ------ 1 file changed, 6 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 27360d3..b273573 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -13,11 +13,6 @@ option(SEIKA_INPUT "Will enable input" ON) option(SEIKA_RENDERING "Will enable rendering" ON) option(SEIKA_AUDIO "Will enable audio" ON) -add_compile_definitions(SKA_ECS=$,1,0>) -add_compile_definitions(SKA_INPUT=$,1,0>) -add_compile_definitions(SKA_RENDERING=$,1,0>) -add_compile_definitions(SKA_AUDIO=$,1,0>) - set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) @@ -25,7 +20,6 @@ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) include(Dependencies.cmake) add_subdirectory(seika) -# Apply the compile definitions to the `seika` target target_compile_definitions(seika PUBLIC SKA_ECS=$,1,0> From 60b93e35e1be500b51341af20b454f0469f6005b Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Wed, 23 Oct 2024 15:16:13 -0400 Subject: [PATCH 40/55] Clean. --- seika/audio/audio.c | 15 +++++++++++++++ seika/audio/audio.h | 2 ++ 2 files changed, 17 insertions(+) diff --git a/seika/audio/audio.c b/seika/audio/audio.c index 32a1e34..ab1d0d6 100644 --- a/seika/audio/audio.c +++ b/seika/audio/audio.c @@ -1,3 +1,5 @@ +#include "audio_manager.h" +#include "seika/assert.h" #if SKA_AUDIO #include "audio.h" @@ -10,9 +12,22 @@ #include "seika/asset/asset_file_loader.h" static uint32 audioWavSampleRate = SKA_AUDIO_SOURCE_DEFAULT_WAV_SAMPLE_RATE; +static bool isAudioInitialized = false; static bool load_wav_data_from_file(const char* file_path, int32* sample_count, int32* channels, int32* sample_rate, void** samples); +void ska_audio_initialize() { + SKA_ASSERT(isAudioInitialized == false); + ska_audio_manager_init(SKA_AUDIO_SOURCE_DEFAULT_WAV_SAMPLE_RATE); + isAudioInitialized = true; +} + +void ska_audio_finalize() { + SKA_ASSERT(isAudioInitialized); + ska_audio_manager_finalize(); + isAudioInitialized = false; +} + void ska_audio_print_audio_source(SkaAudioSource* audioSource) { ska_logger_debug("audio source | channels = %d, sample rate = %d, sample count = %d, samples = %x", audioSource->channels, audioSource->sample_rate, audioSource->sample_count, audioSource->samples); diff --git a/seika/audio/audio.h b/seika/audio/audio.h index 2d50bb4..bf3bbfe 100644 --- a/seika/audio/audio.h +++ b/seika/audio/audio.h @@ -21,6 +21,8 @@ typedef struct SkaAudioSource { int32 sample_count; } SkaAudioSource; +void ska_audio_initialize(); +void ska_audio_finalize(); void ska_audio_print_audio_source(SkaAudioSource* audioSource); void ska_audio_set_wav_sample_rate(uint32 wavSampleRate); uint32 ska_audio_get_wav_sample_rate(); From d83e0040b54662ca5e98b59432835ea7b9e6fc88 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Wed, 23 Oct 2024 22:26:15 -0400 Subject: [PATCH 41/55] Updates. --- CMakeLists.txt | 5 +- seika/input/sdl_input.c | 326 +++++++++++++++++++++++++++++++++++++++ seika/input/sdl_input.h | 326 +-------------------------------------- seika/rendering/window.c | 84 ++++++++++ seika/rendering/window.h | 23 +++ test/game/src/main.c | 66 ++++++++ 6 files changed, 511 insertions(+), 319 deletions(-) create mode 100644 seika/input/sdl_input.c create mode 100644 seika/rendering/window.c create mode 100644 seika/rendering/window.h create mode 100644 test/game/src/main.c diff --git a/CMakeLists.txt b/CMakeLists.txt index b273573..b7a755d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -38,12 +38,15 @@ if (SK_IS_MAIN) # Create seika test exe add_executable(seika_test test/test.c) target_link_libraries(seika_test seika unity) - # Copy directories over that are needed to test if (NOT IS_CI_BUILD) + # Copy directories over that are needed to test add_custom_command(TARGET seika_test POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_directory ${PROJECT_SOURCE_DIR}/test $/test ) + # Create test game executable + add_executable(seika_test_game test/game/src/main.c) + target_link_libraries(seika_test_game seika) endif() endif() diff --git a/seika/input/sdl_input.c b/seika/input/sdl_input.c new file mode 100644 index 0000000..c63e64d --- /dev/null +++ b/seika/input/sdl_input.c @@ -0,0 +1,326 @@ +#if SKA_INPUT + +#include "sdl_input.h" +#include "sdl_gamepad_db.h" + + +typedef struct SkaSDLGamepadData { + SDL_Gamepad* gamepad; + SkaInputDeviceIndex deviceIndex; +} SkaSDLGamepadData; + +static SkaSDLGamepadData gamepadData[SKA_INPUT_MAX_DEVICES]; +static SkaSDLGamepadData gamepadDataByPlayerIndex[SKA_INPUT_MAX_DEVICES]; +static uint32 activeGamepads = 0; + +SkaInputKey ska_sdl_keycode_to_input_key(SDL_GamepadButton keycode) { + switch ((int32)keycode) { + case SDLK_TAB: return SkaInputKey_KEYBOARD_TAB; + case SDLK_LEFT: return SkaInputKey_KEYBOARD_LEFT; + case SDLK_RIGHT: return SkaInputKey_KEYBOARD_RIGHT; + case SDLK_UP: return SkaInputKey_KEYBOARD_UP; + case SDLK_DOWN: return SkaInputKey_KEYBOARD_DOWN; + case SDLK_PAGEDOWN: return SkaInputKey_KEYBOARD_PAGE_DOWN; + case SDLK_PAGEUP: return SkaInputKey_KEYBOARD_PAGE_UP; + case SDLK_HOME: return SkaInputKey_KEYBOARD_HOME; + case SDLK_END: return SkaInputKey_KEYBOARD_END; + case SDLK_INSERT: return SkaInputKey_KEYBOARD_INSERT; + case SDLK_DELETE: return SkaInputKey_KEYBOARD_DELETE; + case SDLK_BACKSPACE: return SkaInputKey_KEYBOARD_BACKSPACE; + case SDLK_SPACE: return SkaInputKey_KEYBOARD_SPACE; + case SDLK_RETURN: return SkaInputKey_KEYBOARD_RETURN; + case SDLK_ESCAPE: return SkaInputKey_KEYBOARD_ESCAPE; + case SDLK_QUOTE: return SkaInputKey_KEYBOARD_QUOTE; + case SDLK_COMMA: return SkaInputKey_KEYBOARD_COMMA; + case SDLK_MINUS: return SkaInputKey_KEYBOARD_MINUS; + case SDLK_PERIOD: return SkaInputKey_KEYBOARD_PERIOD; + case SDLK_SLASH: return SkaInputKey_KEYBOARD_SLASH; + case SDLK_SEMICOLON: return SkaInputKey_KEYBOARD_SEMICOLON; + case SDLK_EQUALS: return SkaInputKey_KEYBOARD_EQUALS; + case SDLK_LEFTBRACKET: return SkaInputKey_KEYBOARD_LEFT_BRACKET; + case SDLK_BACKSLASH: return SkaInputKey_KEYBOARD_BACKSLASH; + case SDLK_RIGHTBRACKET: return SkaInputKey_KEYBOARD_RIGHT_BRACKET; + case SDLK_BACKQUOTE: return SkaInputKey_KEYBOARD_BACKQUOTE; + case SDLK_CAPSLOCK: return SkaInputKey_KEYBOARD_CAPS_LOCK; + case SDLK_SCROLLLOCK: return SkaInputKey_KEYBOARD_SCROLL_LOCK; + case SDLK_NUMLOCKCLEAR: return SkaInputKey_KEYBOARD_NUM_LOCK_CLEAR; + case SDLK_PRINTSCREEN: return SkaInputKey_KEYBOARD_PRINT_SCREEN; + case SDLK_PAUSE: return SkaInputKey_KEYBOARD_PAUSE; + case SDLK_KP_0: return SkaInputKey_KEYBOARD_KEYPAD_0; + case SDLK_KP_1: return SkaInputKey_KEYBOARD_KEYPAD_1; + case SDLK_KP_2: return SkaInputKey_KEYBOARD_KEYPAD_2; + case SDLK_KP_3: return SkaInputKey_KEYBOARD_KEYPAD_3; + case SDLK_KP_4: return SkaInputKey_KEYBOARD_KEYPAD_4; + case SDLK_KP_5: return SkaInputKey_KEYBOARD_KEYPAD_5; + case SDLK_KP_6: return SkaInputKey_KEYBOARD_KEYPAD_6; + case SDLK_KP_7: return SkaInputKey_KEYBOARD_KEYPAD_7; + case SDLK_KP_8: return SkaInputKey_KEYBOARD_KEYPAD_8; + case SDLK_KP_9: return SkaInputKey_KEYBOARD_KEYPAD_9; + case SDLK_KP_PERIOD: return SkaInputKey_KEYBOARD_KEYPAD_PERIOD; + case SDLK_KP_MULTIPLY: return SkaInputKey_KEYBOARD_KEYPAD_MULTIPLY; + case SDLK_KP_MINUS: return SkaInputKey_KEYBOARD_KEYPAD_MINUS; + case SDLK_KP_PLUS: return SkaInputKey_KEYBOARD_KEYPAD_PLUS; + case SDLK_KP_ENTER: return SkaInputKey_KEYBOARD_KEYPAD_ENTER; + case SDLK_KP_EQUALS: return SkaInputKey_KEYBOARD_KEYPAD_EQUALS; + case SDLK_LCTRL: return SkaInputKey_KEYBOARD_LEFT_CONTROL; + case SDLK_LSHIFT: return SkaInputKey_KEYBOARD_LEFT_SHIFT; + case SDLK_LALT: return SkaInputKey_KEYBOARD_LEFT_ALT; + case SDLK_LGUI: return SkaInputKey_KEYBOARD_LEFT_GUI; + case SDLK_RCTRL: return SkaInputKey_KEYBOARD_RIGHT_CONTROL; + case SDLK_RSHIFT: return SkaInputKey_KEYBOARD_RIGHT_SHIFT; + case SDLK_RALT: return SkaInputKey_KEYBOARD_RIGHT_ALT; + case SDLK_RGUI: return SkaInputKey_KEYBOARD_RIGHT_GUI; + case SDLK_APPLICATION: return SkaInputKey_KEYBOARD_APPLICATION; + case SDLK_0: return SkaInputKey_KEYBOARD_NUM_0; + case SDLK_1: return SkaInputKey_KEYBOARD_NUM_1; + case SDLK_2: return SkaInputKey_KEYBOARD_NUM_2; + case SDLK_3: return SkaInputKey_KEYBOARD_NUM_3; + case SDLK_4: return SkaInputKey_KEYBOARD_NUM_4; + case SDLK_5: return SkaInputKey_KEYBOARD_NUM_5; + case SDLK_6: return SkaInputKey_KEYBOARD_NUM_6; + case SDLK_7: return SkaInputKey_KEYBOARD_NUM_7; + case SDLK_8: return SkaInputKey_KEYBOARD_NUM_8; + case SDLK_9: return SkaInputKey_KEYBOARD_NUM_9; + case SDLK_a: return SkaInputKey_KEYBOARD_A; + case SDLK_b: return SkaInputKey_KEYBOARD_B; + case SDLK_c: return SkaInputKey_KEYBOARD_C; + case SDLK_d: return SkaInputKey_KEYBOARD_D; + case SDLK_e: return SkaInputKey_KEYBOARD_E; + case SDLK_f: return SkaInputKey_KEYBOARD_F; + case SDLK_g: return SkaInputKey_KEYBOARD_G; + case SDLK_h: return SkaInputKey_KEYBOARD_H; + case SDLK_i: return SkaInputKey_KEYBOARD_I; + case SDLK_j: return SkaInputKey_KEYBOARD_J; + case SDLK_k: return SkaInputKey_KEYBOARD_K; + case SDLK_l: return SkaInputKey_KEYBOARD_L; + case SDLK_m: return SkaInputKey_KEYBOARD_M; + case SDLK_n: return SkaInputKey_KEYBOARD_N; + case SDLK_o: return SkaInputKey_KEYBOARD_O; + case SDLK_p: return SkaInputKey_KEYBOARD_P; + case SDLK_q: return SkaInputKey_KEYBOARD_Q; + case SDLK_r: return SkaInputKey_KEYBOARD_R; + case SDLK_s: return SkaInputKey_KEYBOARD_S; + case SDLK_t: return SkaInputKey_KEYBOARD_T; + case SDLK_u: return SkaInputKey_KEYBOARD_U; + case SDLK_v: return SkaInputKey_KEYBOARD_V; + case SDLK_w: return SkaInputKey_KEYBOARD_W; + case SDLK_x: return SkaInputKey_KEYBOARD_X; + case SDLK_y: return SkaInputKey_KEYBOARD_Y; + case SDLK_z: return SkaInputKey_KEYBOARD_Z; + case SDLK_F1: return SkaInputKey_KEYBOARD_F1; + case SDLK_F2: return SkaInputKey_KEYBOARD_F2; + case SDLK_F3: return SkaInputKey_KEYBOARD_F3; + case SDLK_F4: return SkaInputKey_KEYBOARD_F4; + case SDLK_F5: return SkaInputKey_KEYBOARD_F5; + case SDLK_F6: return SkaInputKey_KEYBOARD_F6; + case SDLK_F7: return SkaInputKey_KEYBOARD_F7; + case SDLK_F8: return SkaInputKey_KEYBOARD_F8; + case SDLK_F9: return SkaInputKey_KEYBOARD_F9; + case SDLK_F10: return SkaInputKey_KEYBOARD_F10; + case SDLK_F11: return SkaInputKey_KEYBOARD_F11; + case SDLK_F12: return SkaInputKey_KEYBOARD_F12; + case SDLK_F13: return SkaInputKey_KEYBOARD_F13; + case SDLK_F14: return SkaInputKey_KEYBOARD_F14; + case SDLK_F15: return SkaInputKey_KEYBOARD_F15; + case SDLK_F16: return SkaInputKey_KEYBOARD_F16; + case SDLK_F17: return SkaInputKey_KEYBOARD_F17; + case SDLK_F18: return SkaInputKey_KEYBOARD_F18; + case SDLK_F19: return SkaInputKey_KEYBOARD_F19; + case SDLK_F20: return SkaInputKey_KEYBOARD_F20; + case SDLK_F21: return SkaInputKey_KEYBOARD_F21; + case SDLK_F22: return SkaInputKey_KEYBOARD_F22; + case SDLK_F23: return SkaInputKey_KEYBOARD_F23; + case SDLK_F24: return SkaInputKey_KEYBOARD_F24; + case SDLK_AC_BACK: return SkaInputKey_KEYBOARD_APP_BACK; + case SDLK_AC_FORWARD: return SkaInputKey_KEYBOARD_APP_FORWARD; + default: return SkaInputKey_INVALID; + } +} + + +SkaInputKey ska_sdl_mouse_button_to_input_key(SDL_MouseButtonEvent button) { + switch (button.button) { + case SDL_BUTTON_LEFT: return SkaInputKey_MOUSE_BUTTON_LEFT; + case SDL_BUTTON_RIGHT: return SkaInputKey_MOUSE_BUTTON_RIGHT; + case SDL_BUTTON_MIDDLE: return SkaInputKey_MOUSE_BUTTON_MIDDLE; + default: return SkaInputKey_INVALID; + } +} + +SkaInputKey ska_sdl_gamepad_button_to_input_key(SDL_GamepadButton button) { + switch (button) { + case SDL_GAMEPAD_BUTTON_SOUTH: return SkaInputKey_GAMEPAD_FACE_BUTTON_SOUTH; + case SDL_GAMEPAD_BUTTON_EAST: return SkaInputKey_GAMEPAD_FACE_BUTTON_EAST; + case SDL_GAMEPAD_BUTTON_WEST: return SkaInputKey_GAMEPAD_FACE_BUTTON_WEST; + case SDL_GAMEPAD_BUTTON_NORTH: return SkaInputKey_GAMEPAD_FACE_BUTTON_NORTH; + case SDL_GAMEPAD_BUTTON_BACK: return SkaInputKey_GAMEPAD_BACK; + case SDL_GAMEPAD_BUTTON_START: return SkaInputKey_GAMEPAD_START; + case SDL_GAMEPAD_BUTTON_LEFT_STICK: return SkaInputKey_GAMEPAD_LEFT_ANALOG_BUTTON; + case SDL_GAMEPAD_BUTTON_RIGHT_STICK: return SkaInputKey_GAMEPAD_RIGHT_ANALOG_BUTTON; + case SDL_GAMEPAD_BUTTON_LEFT_SHOULDER: return SkaInputKey_GAMEPAD_LEFT_SHOULDER; + case SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER: return SkaInputKey_GAMEPAD_RIGHT_SHOULDER; + case SDL_GAMEPAD_BUTTON_DPAD_UP: return SkaInputKey_GAMEPAD_DPAD_UP; + case SDL_GAMEPAD_BUTTON_DPAD_DOWN: return SkaInputKey_GAMEPAD_DPAD_DOWN; + case SDL_GAMEPAD_BUTTON_DPAD_LEFT: return SkaInputKey_GAMEPAD_DPAD_LEFT; + case SDL_GAMEPAD_BUTTON_DPAD_RIGHT: return SkaInputKey_GAMEPAD_DPAD_RIGHT; + default: return SkaInputKey_INVALID; + } +} + +SkaInputKey ska_sdl_gamepad_axis_to_input_key(SDL_GamepadAxis axis) { + switch (axis) { + case SDL_GAMEPAD_AXIS_LEFTX: return SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X; + case SDL_GAMEPAD_AXIS_LEFTY: return SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y; + case SDL_GAMEPAD_AXIS_RIGHTX: return SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X; + case SDL_GAMEPAD_AXIS_RIGHTY: return SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_Y; + case SDL_GAMEPAD_AXIS_LEFT_TRIGGER: return SkaInputKey_GAMEPAD_LEFT_TRIGGER; + case SDL_GAMEPAD_AXIS_RIGHT_TRIGGER: return SkaInputKey_GAMEPAD_RIGHT_TRIGGER; + default: return SkaInputKey_INVALID; + } +} + +bool ska_sdl_load_gamepad_mappings() { + const int loadResult = SDL_AddGamepadMapping(SKA_GAMEPAD_DB_STR); + return loadResult >= 0; +} + +void ska_sdl_notify_input_event(const SkaSDLInputEvent* inputEvent) { + ska_input_register_input_event(inputEvent->sourceType, inputEvent->key, inputEvent->triggerType, inputEvent->deviceIndex, inputEvent->axisMotionValue); +} + +void ska_sdl_process_event(SDL_Event event) { + SkaSDLInputEvent inputEvent = { + .sourceType = SkaInputSourceType_INVALID, + .triggerType = SkaInputTriggerType_INVALID, + .deviceIndex = SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, + .key = SkaInputKey_INVALID, + .axisMotionValue = 0.0f + }; + + switch (event.type) { + // Mouse + case SDL_EVENT_MOUSE_MOTION: { + SkaMouse* mouse = ska_input_get_mouse(); + mouse->position = (SkaVector2){ .x = (f32)event.motion.x, .y = (f32)event.motion.y }; + break; + } + + case SDL_EVENT_MOUSE_BUTTON_DOWN: + case SDL_EVENT_MOUSE_BUTTON_UP: { + inputEvent.sourceType = SkaInputSourceType_MOUSE; + inputEvent.triggerType = event.type == SDL_EVENT_MOUSE_BUTTON_DOWN ? SkaInputTriggerType_PRESSED : SkaInputTriggerType_RELEASED; + inputEvent.key = ska_sdl_mouse_button_to_input_key(event.button); + break; + } + // Keyboard + case SDL_EVENT_KEY_DOWN: + case SDL_EVENT_KEY_UP: { + inputEvent.sourceType = SkaInputSourceType_KEYBOARD; + inputEvent.triggerType = event.type == SDL_EVENT_KEY_DOWN ? SkaInputTriggerType_PRESSED : SkaInputTriggerType_RELEASED, + inputEvent.key = ska_sdl_keycode_to_input_key(event.key.keysym.sym); + break; + } + // Gamepad + case SDL_EVENT_GAMEPAD_ADDED: { + const SDL_JoystickID deviceIndex = event.gdevice.which; + SDL_Gamepad* newGamepad = SDL_OpenGamepad(deviceIndex); + const int playerIndex = SDL_GetGamepadPlayerIndex(newGamepad); + const SkaSDLGamepadData newGamepadData = { .gamepad = newGamepad, .deviceIndex = playerIndex }; + gamepadData[deviceIndex] = newGamepadData; + gamepadDataByPlayerIndex[playerIndex] = newGamepadData; + activeGamepads++; + + inputEvent.sourceType = SkaInputSourceType_GAMEPAD; + inputEvent.triggerType = SkaInputTriggerType_DEVICE_ADDED; + inputEvent.deviceIndex = playerIndex; + break; + } + case SDL_EVENT_GAMEPAD_REMOVED: { + const SDL_JoystickID deviceIndex = event.gdevice.which; + SDL_Gamepad* removedGamepad = gamepadData[deviceIndex].gamepad; + const SkaInputDeviceIndex playerIndex = gamepadData[deviceIndex].deviceIndex; + SDL_CloseGamepad(removedGamepad); + const SkaSDLGamepadData defaultGamepadData = (SkaSDLGamepadData){ .gamepad = NULL, .deviceIndex = -1 }; + gamepadData[deviceIndex] = defaultGamepadData; + gamepadDataByPlayerIndex[playerIndex] = defaultGamepadData; + activeGamepads--; + + inputEvent.sourceType = SkaInputSourceType_GAMEPAD; + inputEvent.triggerType = SkaInputTriggerType_DEVICE_REMOVED; + inputEvent.deviceIndex = playerIndex; + break; + } + case SDL_EVENT_GAMEPAD_BUTTON_DOWN: + case SDL_EVENT_GAMEPAD_BUTTON_UP: { + const SDL_JoystickID deviceIndex = event.jbutton.which; + const SkaInputDeviceIndex playerIndex = gamepadData[deviceIndex].deviceIndex; + const bool isButtonPressed = event.jbutton.state == SDL_PRESSED; + const SDL_GamepadButton buttonValue = event.jbutton.button; + + inputEvent.sourceType = SkaInputSourceType_GAMEPAD; + inputEvent.triggerType = isButtonPressed ? SkaInputTriggerType_PRESSED : SkaInputTriggerType_RELEASED; + inputEvent.deviceIndex = playerIndex; + inputEvent.key = ska_sdl_gamepad_button_to_input_key(buttonValue); + break; + } + default: + break; + } + ska_sdl_notify_input_event(&inputEvent); +} + +// Call after looping through all sdl input events for a frame +void ska_sdl_process_axis_events() { +#define SKA_SDL_GAMEPAD_AXIS_DEAD_ZONE 8000 +#define SKA_MAX_AXIS_VALUES 6 + + static const SDL_GamepadAxis AXIS_KEYS[SKA_MAX_AXIS_VALUES] = { + SDL_GAMEPAD_AXIS_LEFTX, SDL_GAMEPAD_AXIS_LEFTY, + SDL_GAMEPAD_AXIS_RIGHTX, SDL_GAMEPAD_AXIS_RIGHTY, + SDL_GAMEPAD_AXIS_LEFT_TRIGGER, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER + }; + static bool hasGamepadStoppedAxisMotion[SKA_INPUT_MAX_DEVICES][SKA_MAX_AXIS_VALUES] = { + {true, true, true, true, true, true}, + {true, true, true, true, true, true}, + {true, true, true, true, true, true}, + {true, true, true, true, true, true}, + {true, true, true, true, true, true}, + {true, true, true, true, true, true}, + {true, true, true, true, true, true}, + {true, true, true, true, true, true} + }; + + for (uint32 i = 0; i < activeGamepads; i++) { + SkaSDLGamepadData* currentGamepadData = &gamepadDataByPlayerIndex[i]; + for (SDL_GamepadAxis axis = 0; axis < SKA_MAX_AXIS_VALUES; axis++) { + const int16 axisValue = SDL_GetGamepadAxis(currentGamepadData->gamepad, axis); + const SkaInputTriggerType triggerType = + axisValue < SKA_SDL_GAMEPAD_AXIS_DEAD_ZONE && axisValue > -SKA_SDL_GAMEPAD_AXIS_DEAD_ZONE + ? SkaInputTriggerType_AXIS_STOPPED_MOTION : SkaInputTriggerType_AXIS_IN_MOTION; + // Skip sending event if axis motion is already stopped + bool *hasStoppedAxisMotion = &hasGamepadStoppedAxisMotion[i][axis]; + if (triggerType == SkaInputTriggerType_AXIS_STOPPED_MOTION) { + if (*hasStoppedAxisMotion) { + continue; + } else { + *hasStoppedAxisMotion = true; + } + } else { + *hasStoppedAxisMotion = false; + } + const f32 axisValueNormalized = ska_math_map_to_range((f32) axisValue, (f32) INT16_MIN, (f32) INT16_MAX,-1.0f, 1.0f); + const SkaSDLInputEvent inputEvent = { + .sourceType = SkaInputSourceType_GAMEPAD, + .triggerType = triggerType, + .deviceIndex = (SkaInputDeviceIndex)i, + .key = ska_sdl_gamepad_axis_to_input_key(axis), + .axisMotionValue = axisValueNormalized + }; + ska_sdl_notify_input_event(&inputEvent); + } + } + +#undef SKA_MAX_AXIS_VALUES +} + +#endif // #if SKA_INPUT \ No newline at end of file diff --git a/seika/input/sdl_input.h b/seika/input/sdl_input.h index 070e1ff..a9907d5 100644 --- a/seika/input/sdl_input.h +++ b/seika/input/sdl_input.h @@ -5,12 +5,6 @@ #include #include "input.h" -#include "sdl_gamepad_db.h" - -typedef struct SkaSDLGamepadData { - SDL_Gamepad* gamepad; - SkaInputDeviceIndex deviceIndex; -} SkaSDLGamepadData; typedef struct SkaSDLInputEvent { SkaInputSourceType sourceType; @@ -20,318 +14,14 @@ typedef struct SkaSDLInputEvent { f32 axisMotionValue; } SkaSDLInputEvent; -static SkaSDLGamepadData gamepadData[SKA_INPUT_MAX_DEVICES]; -static SkaSDLGamepadData gamepadDataByPlayerIndex[SKA_INPUT_MAX_DEVICES]; -static uint32 activeGamepads = 0; - -SkaInputKey ska_sdl_keycode_to_input_key(SDL_GamepadButton keycode) { - switch ((int32)keycode) { - case SDLK_TAB: return SkaInputKey_KEYBOARD_TAB; - case SDLK_LEFT: return SkaInputKey_KEYBOARD_LEFT; - case SDLK_RIGHT: return SkaInputKey_KEYBOARD_RIGHT; - case SDLK_UP: return SkaInputKey_KEYBOARD_UP; - case SDLK_DOWN: return SkaInputKey_KEYBOARD_DOWN; - case SDLK_PAGEDOWN: return SkaInputKey_KEYBOARD_PAGE_DOWN; - case SDLK_PAGEUP: return SkaInputKey_KEYBOARD_PAGE_UP; - case SDLK_HOME: return SkaInputKey_KEYBOARD_HOME; - case SDLK_END: return SkaInputKey_KEYBOARD_END; - case SDLK_INSERT: return SkaInputKey_KEYBOARD_INSERT; - case SDLK_DELETE: return SkaInputKey_KEYBOARD_DELETE; - case SDLK_BACKSPACE: return SkaInputKey_KEYBOARD_BACKSPACE; - case SDLK_SPACE: return SkaInputKey_KEYBOARD_SPACE; - case SDLK_RETURN: return SkaInputKey_KEYBOARD_RETURN; - case SDLK_ESCAPE: return SkaInputKey_KEYBOARD_ESCAPE; - case SDLK_QUOTE: return SkaInputKey_KEYBOARD_QUOTE; - case SDLK_COMMA: return SkaInputKey_KEYBOARD_COMMA; - case SDLK_MINUS: return SkaInputKey_KEYBOARD_MINUS; - case SDLK_PERIOD: return SkaInputKey_KEYBOARD_PERIOD; - case SDLK_SLASH: return SkaInputKey_KEYBOARD_SLASH; - case SDLK_SEMICOLON: return SkaInputKey_KEYBOARD_SEMICOLON; - case SDLK_EQUALS: return SkaInputKey_KEYBOARD_EQUALS; - case SDLK_LEFTBRACKET: return SkaInputKey_KEYBOARD_LEFT_BRACKET; - case SDLK_BACKSLASH: return SkaInputKey_KEYBOARD_BACKSLASH; - case SDLK_RIGHTBRACKET: return SkaInputKey_KEYBOARD_RIGHT_BRACKET; - case SDLK_BACKQUOTE: return SkaInputKey_KEYBOARD_BACKQUOTE; - case SDLK_CAPSLOCK: return SkaInputKey_KEYBOARD_CAPS_LOCK; - case SDLK_SCROLLLOCK: return SkaInputKey_KEYBOARD_SCROLL_LOCK; - case SDLK_NUMLOCKCLEAR: return SkaInputKey_KEYBOARD_NUM_LOCK_CLEAR; - case SDLK_PRINTSCREEN: return SkaInputKey_KEYBOARD_PRINT_SCREEN; - case SDLK_PAUSE: return SkaInputKey_KEYBOARD_PAUSE; - case SDLK_KP_0: return SkaInputKey_KEYBOARD_KEYPAD_0; - case SDLK_KP_1: return SkaInputKey_KEYBOARD_KEYPAD_1; - case SDLK_KP_2: return SkaInputKey_KEYBOARD_KEYPAD_2; - case SDLK_KP_3: return SkaInputKey_KEYBOARD_KEYPAD_3; - case SDLK_KP_4: return SkaInputKey_KEYBOARD_KEYPAD_4; - case SDLK_KP_5: return SkaInputKey_KEYBOARD_KEYPAD_5; - case SDLK_KP_6: return SkaInputKey_KEYBOARD_KEYPAD_6; - case SDLK_KP_7: return SkaInputKey_KEYBOARD_KEYPAD_7; - case SDLK_KP_8: return SkaInputKey_KEYBOARD_KEYPAD_8; - case SDLK_KP_9: return SkaInputKey_KEYBOARD_KEYPAD_9; - case SDLK_KP_PERIOD: return SkaInputKey_KEYBOARD_KEYPAD_PERIOD; - case SDLK_KP_MULTIPLY: return SkaInputKey_KEYBOARD_KEYPAD_MULTIPLY; - case SDLK_KP_MINUS: return SkaInputKey_KEYBOARD_KEYPAD_MINUS; - case SDLK_KP_PLUS: return SkaInputKey_KEYBOARD_KEYPAD_PLUS; - case SDLK_KP_ENTER: return SkaInputKey_KEYBOARD_KEYPAD_ENTER; - case SDLK_KP_EQUALS: return SkaInputKey_KEYBOARD_KEYPAD_EQUALS; - case SDLK_LCTRL: return SkaInputKey_KEYBOARD_LEFT_CONTROL; - case SDLK_LSHIFT: return SkaInputKey_KEYBOARD_LEFT_SHIFT; - case SDLK_LALT: return SkaInputKey_KEYBOARD_LEFT_ALT; - case SDLK_LGUI: return SkaInputKey_KEYBOARD_LEFT_GUI; - case SDLK_RCTRL: return SkaInputKey_KEYBOARD_RIGHT_CONTROL; - case SDLK_RSHIFT: return SkaInputKey_KEYBOARD_RIGHT_SHIFT; - case SDLK_RALT: return SkaInputKey_KEYBOARD_RIGHT_ALT; - case SDLK_RGUI: return SkaInputKey_KEYBOARD_RIGHT_GUI; - case SDLK_APPLICATION: return SkaInputKey_KEYBOARD_APPLICATION; - case SDLK_0: return SkaInputKey_KEYBOARD_NUM_0; - case SDLK_1: return SkaInputKey_KEYBOARD_NUM_1; - case SDLK_2: return SkaInputKey_KEYBOARD_NUM_2; - case SDLK_3: return SkaInputKey_KEYBOARD_NUM_3; - case SDLK_4: return SkaInputKey_KEYBOARD_NUM_4; - case SDLK_5: return SkaInputKey_KEYBOARD_NUM_5; - case SDLK_6: return SkaInputKey_KEYBOARD_NUM_6; - case SDLK_7: return SkaInputKey_KEYBOARD_NUM_7; - case SDLK_8: return SkaInputKey_KEYBOARD_NUM_8; - case SDLK_9: return SkaInputKey_KEYBOARD_NUM_9; - case SDLK_a: return SkaInputKey_KEYBOARD_A; - case SDLK_b: return SkaInputKey_KEYBOARD_B; - case SDLK_c: return SkaInputKey_KEYBOARD_C; - case SDLK_d: return SkaInputKey_KEYBOARD_D; - case SDLK_e: return SkaInputKey_KEYBOARD_E; - case SDLK_f: return SkaInputKey_KEYBOARD_F; - case SDLK_g: return SkaInputKey_KEYBOARD_G; - case SDLK_h: return SkaInputKey_KEYBOARD_H; - case SDLK_i: return SkaInputKey_KEYBOARD_I; - case SDLK_j: return SkaInputKey_KEYBOARD_J; - case SDLK_k: return SkaInputKey_KEYBOARD_K; - case SDLK_l: return SkaInputKey_KEYBOARD_L; - case SDLK_m: return SkaInputKey_KEYBOARD_M; - case SDLK_n: return SkaInputKey_KEYBOARD_N; - case SDLK_o: return SkaInputKey_KEYBOARD_O; - case SDLK_p: return SkaInputKey_KEYBOARD_P; - case SDLK_q: return SkaInputKey_KEYBOARD_Q; - case SDLK_r: return SkaInputKey_KEYBOARD_R; - case SDLK_s: return SkaInputKey_KEYBOARD_S; - case SDLK_t: return SkaInputKey_KEYBOARD_T; - case SDLK_u: return SkaInputKey_KEYBOARD_U; - case SDLK_v: return SkaInputKey_KEYBOARD_V; - case SDLK_w: return SkaInputKey_KEYBOARD_W; - case SDLK_x: return SkaInputKey_KEYBOARD_X; - case SDLK_y: return SkaInputKey_KEYBOARD_Y; - case SDLK_z: return SkaInputKey_KEYBOARD_Z; - case SDLK_F1: return SkaInputKey_KEYBOARD_F1; - case SDLK_F2: return SkaInputKey_KEYBOARD_F2; - case SDLK_F3: return SkaInputKey_KEYBOARD_F3; - case SDLK_F4: return SkaInputKey_KEYBOARD_F4; - case SDLK_F5: return SkaInputKey_KEYBOARD_F5; - case SDLK_F6: return SkaInputKey_KEYBOARD_F6; - case SDLK_F7: return SkaInputKey_KEYBOARD_F7; - case SDLK_F8: return SkaInputKey_KEYBOARD_F8; - case SDLK_F9: return SkaInputKey_KEYBOARD_F9; - case SDLK_F10: return SkaInputKey_KEYBOARD_F10; - case SDLK_F11: return SkaInputKey_KEYBOARD_F11; - case SDLK_F12: return SkaInputKey_KEYBOARD_F12; - case SDLK_F13: return SkaInputKey_KEYBOARD_F13; - case SDLK_F14: return SkaInputKey_KEYBOARD_F14; - case SDLK_F15: return SkaInputKey_KEYBOARD_F15; - case SDLK_F16: return SkaInputKey_KEYBOARD_F16; - case SDLK_F17: return SkaInputKey_KEYBOARD_F17; - case SDLK_F18: return SkaInputKey_KEYBOARD_F18; - case SDLK_F19: return SkaInputKey_KEYBOARD_F19; - case SDLK_F20: return SkaInputKey_KEYBOARD_F20; - case SDLK_F21: return SkaInputKey_KEYBOARD_F21; - case SDLK_F22: return SkaInputKey_KEYBOARD_F22; - case SDLK_F23: return SkaInputKey_KEYBOARD_F23; - case SDLK_F24: return SkaInputKey_KEYBOARD_F24; - case SDLK_AC_BACK: return SkaInputKey_KEYBOARD_APP_BACK; - case SDLK_AC_FORWARD: return SkaInputKey_KEYBOARD_APP_FORWARD; - default: return SkaInputKey_INVALID; - } -} - - -SkaInputKey ska_sdl_mouse_button_to_input_key(SDL_MouseButtonEvent button) { - switch (button.button) { - case SDL_BUTTON_LEFT: return SkaInputKey_MOUSE_BUTTON_LEFT; - case SDL_BUTTON_RIGHT: return SkaInputKey_MOUSE_BUTTON_RIGHT; - case SDL_BUTTON_MIDDLE: return SkaInputKey_MOUSE_BUTTON_MIDDLE; - default: return SkaInputKey_INVALID; - } -} - -SkaInputKey ska_sdl_gamepad_button_to_input_key(SDL_GamepadButton button) { - switch (button) { - case SDL_GAMEPAD_BUTTON_SOUTH: return SkaInputKey_GAMEPAD_FACE_BUTTON_SOUTH; - case SDL_GAMEPAD_BUTTON_EAST: return SkaInputKey_GAMEPAD_FACE_BUTTON_EAST; - case SDL_GAMEPAD_BUTTON_WEST: return SkaInputKey_GAMEPAD_FACE_BUTTON_WEST; - case SDL_GAMEPAD_BUTTON_NORTH: return SkaInputKey_GAMEPAD_FACE_BUTTON_NORTH; - case SDL_GAMEPAD_BUTTON_BACK: return SkaInputKey_GAMEPAD_BACK; - case SDL_GAMEPAD_BUTTON_START: return SkaInputKey_GAMEPAD_START; - case SDL_GAMEPAD_BUTTON_LEFT_STICK: return SkaInputKey_GAMEPAD_LEFT_ANALOG_BUTTON; - case SDL_GAMEPAD_BUTTON_RIGHT_STICK: return SkaInputKey_GAMEPAD_RIGHT_ANALOG_BUTTON; - case SDL_GAMEPAD_BUTTON_LEFT_SHOULDER: return SkaInputKey_GAMEPAD_LEFT_SHOULDER; - case SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER: return SkaInputKey_GAMEPAD_RIGHT_SHOULDER; - case SDL_GAMEPAD_BUTTON_DPAD_UP: return SkaInputKey_GAMEPAD_DPAD_UP; - case SDL_GAMEPAD_BUTTON_DPAD_DOWN: return SkaInputKey_GAMEPAD_DPAD_DOWN; - case SDL_GAMEPAD_BUTTON_DPAD_LEFT: return SkaInputKey_GAMEPAD_DPAD_LEFT; - case SDL_GAMEPAD_BUTTON_DPAD_RIGHT: return SkaInputKey_GAMEPAD_DPAD_RIGHT; - default: return SkaInputKey_INVALID; - } -} - -SkaInputKey ska_sdl_gamepad_axis_to_input_key(SDL_GamepadAxis axis) { - switch (axis) { - case SDL_GAMEPAD_AXIS_LEFTX: return SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X; - case SDL_GAMEPAD_AXIS_LEFTY: return SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y; - case SDL_GAMEPAD_AXIS_RIGHTX: return SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X; - case SDL_GAMEPAD_AXIS_RIGHTY: return SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_Y; - case SDL_GAMEPAD_AXIS_LEFT_TRIGGER: return SkaInputKey_GAMEPAD_LEFT_TRIGGER; - case SDL_GAMEPAD_AXIS_RIGHT_TRIGGER: return SkaInputKey_GAMEPAD_RIGHT_TRIGGER; - default: return SkaInputKey_INVALID; - } -} - -bool ska_sdl_load_gamepad_mappings() { - const int loadResult = SDL_AddGamepadMapping(SKA_GAMEPAD_DB_STR); - return loadResult >= 0; -} - -static inline void ska_sdl_notify_input_event(const SkaSDLInputEvent* inputEvent) { - ska_input_register_input_event(inputEvent->sourceType, inputEvent->key, inputEvent->triggerType, inputEvent->deviceIndex, inputEvent->axisMotionValue); -} - -void ska_sdl_process_event(SDL_Event event) { - SkaSDLInputEvent inputEvent = { - .sourceType = SkaInputSourceType_INVALID, - .triggerType = SkaInputTriggerType_INVALID, - .deviceIndex = SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, - .key = SkaInputKey_INVALID, - .axisMotionValue = 0.0f - }; - - switch (event.type) { - // Mouse - case SDL_EVENT_MOUSE_MOTION: { - SkaMouse* mouse = ska_input_get_mouse(); - mouse->position = (SkaVector2){ .x = (f32)event.motion.x, .y = (f32)event.motion.y }; - break; - } - - case SDL_EVENT_MOUSE_BUTTON_DOWN: - case SDL_EVENT_MOUSE_BUTTON_UP: { - inputEvent.sourceType = SkaInputSourceType_MOUSE; - inputEvent.triggerType = event.type == SDL_EVENT_MOUSE_BUTTON_DOWN ? SkaInputTriggerType_PRESSED : SkaInputTriggerType_RELEASED; - inputEvent.key = ska_sdl_mouse_button_to_input_key(event.button); - break; - } - // Keyboard - case SDL_EVENT_KEY_DOWN: - case SDL_EVENT_KEY_UP: { - inputEvent.sourceType = SkaInputSourceType_KEYBOARD; - inputEvent.triggerType = event.type == SDL_EVENT_KEY_DOWN ? SkaInputTriggerType_PRESSED : SkaInputTriggerType_RELEASED, - inputEvent.key = ska_sdl_keycode_to_input_key(event.key.keysym.sym); - break; - } - // Gamepad - case SDL_EVENT_GAMEPAD_ADDED: { - const SDL_JoystickID deviceIndex = event.gdevice.which; - SDL_Gamepad* newGamepad = SDL_OpenGamepad(deviceIndex); - const int playerIndex = SDL_GetGamepadPlayerIndex(newGamepad); - const SkaSDLGamepadData newGamepadData = { .gamepad = newGamepad, .deviceIndex = playerIndex }; - gamepadData[deviceIndex] = newGamepadData; - gamepadDataByPlayerIndex[playerIndex] = newGamepadData; - activeGamepads++; - - inputEvent.sourceType = SkaInputSourceType_GAMEPAD; - inputEvent.triggerType = SkaInputTriggerType_DEVICE_ADDED; - inputEvent.deviceIndex = playerIndex; - break; - } - case SDL_EVENT_GAMEPAD_REMOVED: { - const SDL_JoystickID deviceIndex = event.gdevice.which; - SDL_Gamepad* removedGamepad = gamepadData[deviceIndex].gamepad; - const SkaInputDeviceIndex playerIndex = gamepadData[deviceIndex].deviceIndex; - SDL_CloseGamepad(removedGamepad); - const SkaSDLGamepadData defaultGamepadData = (SkaSDLGamepadData){ .gamepad = NULL, .deviceIndex = -1 }; - gamepadData[deviceIndex] = defaultGamepadData; - gamepadDataByPlayerIndex[playerIndex] = defaultGamepadData; - activeGamepads--; - - inputEvent.sourceType = SkaInputSourceType_GAMEPAD; - inputEvent.triggerType = SkaInputTriggerType_DEVICE_REMOVED; - inputEvent.deviceIndex = playerIndex; - break; - } - case SDL_EVENT_GAMEPAD_BUTTON_DOWN: - case SDL_EVENT_GAMEPAD_BUTTON_UP: { - const SDL_JoystickID deviceIndex = event.jbutton.which; - const SkaInputDeviceIndex playerIndex = gamepadData[deviceIndex].deviceIndex; - const bool isButtonPressed = event.jbutton.state == SDL_PRESSED; - const SDL_GamepadButton buttonValue = event.jbutton.button; - - inputEvent.sourceType = SkaInputSourceType_GAMEPAD; - inputEvent.triggerType = isButtonPressed ? SkaInputTriggerType_PRESSED : SkaInputTriggerType_RELEASED; - inputEvent.deviceIndex = playerIndex; - inputEvent.key = ska_sdl_gamepad_button_to_input_key(buttonValue); - break; - } - default: - break; - } - ska_sdl_notify_input_event(&inputEvent); -} - +SkaInputKey ska_sdl_keycode_to_input_key(SDL_GamepadButton keycode); +SkaInputKey ska_sdl_mouse_button_to_input_key(SDL_MouseButtonEvent button); +SkaInputKey ska_sdl_gamepad_button_to_input_key(SDL_GamepadButton button); +SkaInputKey ska_sdl_gamepad_axis_to_input_key(SDL_GamepadAxis axis); +bool ska_sdl_load_gamepad_mappings(); +void ska_sdl_notify_input_event(const SkaSDLInputEvent* inputEvent); +void ska_sdl_process_event(SDL_Event event); // Call after looping through all sdl input events for a frame -void ska_sdl_process_axis_events() { -#define SKA_SDL_GAMEPAD_AXIS_DEAD_ZONE 8000 -#define SKA_MAX_AXIS_VALUES 6 - - static const SDL_GamepadAxis AXIS_KEYS[SKA_MAX_AXIS_VALUES] = { - SDL_GAMEPAD_AXIS_LEFTX, SDL_GAMEPAD_AXIS_LEFTY, - SDL_GAMEPAD_AXIS_RIGHTX, SDL_GAMEPAD_AXIS_RIGHTY, - SDL_GAMEPAD_AXIS_LEFT_TRIGGER, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER - }; - static bool hasGamepadStoppedAxisMotion[SKA_INPUT_MAX_DEVICES][SKA_MAX_AXIS_VALUES] = { - {true, true, true, true, true, true}, - {true, true, true, true, true, true}, - {true, true, true, true, true, true}, - {true, true, true, true, true, true}, - {true, true, true, true, true, true}, - {true, true, true, true, true, true}, - {true, true, true, true, true, true}, - {true, true, true, true, true, true} - }; - - for (uint32 i = 0; i < activeGamepads; i++) { - SkaSDLGamepadData* currentGamepadData = &gamepadDataByPlayerIndex[i]; - for (SDL_GamepadAxis axis = 0; axis < SKA_MAX_AXIS_VALUES; axis++) { - const int16 axisValue = SDL_GetGamepadAxis(currentGamepadData->gamepad, axis); - const SkaInputTriggerType triggerType = - axisValue < SKA_SDL_GAMEPAD_AXIS_DEAD_ZONE && axisValue > -SKA_SDL_GAMEPAD_AXIS_DEAD_ZONE - ? SkaInputTriggerType_AXIS_STOPPED_MOTION : SkaInputTriggerType_AXIS_IN_MOTION; - // Skip sending event if axis motion is already stopped - bool *hasStoppedAxisMotion = &hasGamepadStoppedAxisMotion[i][axis]; - if (triggerType == SkaInputTriggerType_AXIS_STOPPED_MOTION) { - if (*hasStoppedAxisMotion) { - continue; - } else { - *hasStoppedAxisMotion = true; - } - } else { - *hasStoppedAxisMotion = false; - } - const f32 axisValueNormalized = ska_math_map_to_range((f32) axisValue, (f32) INT16_MIN, (f32) INT16_MAX,-1.0f, 1.0f); - const SkaSDLInputEvent inputEvent = { - .sourceType = SkaInputSourceType_GAMEPAD, - .triggerType = triggerType, - .deviceIndex = (SkaInputDeviceIndex)i, - .key = ska_sdl_gamepad_axis_to_input_key(axis), - .axisMotionValue = axisValueNormalized - }; - ska_sdl_notify_input_event(&inputEvent); - } - } - -#undef SKA_MAX_AXIS_VALUES -} +void ska_sdl_process_axis_events(); #endif // if SKA_INPUT diff --git a/seika/rendering/window.c b/seika/rendering/window.c new file mode 100644 index 0000000..2a0f59f --- /dev/null +++ b/seika/rendering/window.c @@ -0,0 +1,84 @@ +#if SKA_RENDERING + +#include "window.h" + +#include +#include + +#include "renderer.h" +#include "seika/assert.h" + +static SDL_Window* window = NULL; +static SDL_GLContext glContext; +static bool isWindowActive = false; + +bool ska_window_initialize(SkaWindowProperties props) { + SKA_ASSERT(isWindowActive == false); + + const bool isSDLInitialized = SDL_WasInit(0) != 0; + if (isSDLInitialized) { + if (SDL_InitSubSystem( SDL_INIT_VIDEO) != 0) { + return false; + } + } else { + if (SDL_Init( SDL_INIT_VIDEO) != 0) { + return false; + } + } + + // OpenGL attributes + SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); + SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24); + SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8); + + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3); + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3); + SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); + + // Create window + const uint32 windowFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIGH_PIXEL_DENSITY; + window = SDL_CreateWindow( + props.title, + props.windowWidth, + props.windowHeight, + windowFlags + ); + if (!window) { + return false; + } + + // Create OpenGL Context + glContext = SDL_GL_CreateContext(window); + + // Initialize Glad + if (!gladLoadGLLoader((GLADloadproc)SDL_GL_GetProcAddress)) { + return false; + } + + // Initialize rendering + ska_renderer_initialize(props.windowWidth, props.windowHeight, props.resolutionWidth, props.resolutionHeight, props.maintainAspectRatio); + + isWindowActive = true; + return true; +} + +void ska_window_finalize() { + SKA_ASSERT(isWindowActive); + SDL_GL_DeleteContext(glContext); + SDL_DestroyWindow(window); + SDL_QuitSubSystem(SDL_INIT_VIDEO); + const bool subsystemsStillInitialized = SDL_WasInit(0) != 0; + if (!subsystemsStillInitialized) { + SDL_Quit(); + } + + window = NULL; +} + +void ska_window_render(const SkaColor* backgroundColor) { + SKA_ASSERT(isWindowActive); + ska_renderer_process_and_flush_batches(backgroundColor); + SDL_GL_SwapWindow(window); +} + +#endif // #if SKA_RENDERING diff --git a/seika/rendering/window.h b/seika/rendering/window.h new file mode 100644 index 0000000..4daaa52 --- /dev/null +++ b/seika/rendering/window.h @@ -0,0 +1,23 @@ +#pragma once + +#if SKA_RENDERING + +#include "seika/defines.h" + +struct SkaColor; + +typedef struct SkaWindowProperties { + const char* title; + int32 windowWidth; + int32 windowHeight; + int32 resolutionWidth; + int32 resolutionHeight; + bool maintainAspectRatio; +} SkaWindowProperties; + +bool ska_window_initialize(SkaWindowProperties props); +void ska_window_finalize(); +void ska_window_render(const struct SkaColor* backgroundColor); + +#endif // #if SKA_RENDERING + diff --git a/test/game/src/main.c b/test/game/src/main.c new file mode 100644 index 0000000..578e11a --- /dev/null +++ b/test/game/src/main.c @@ -0,0 +1,66 @@ +#include + +#include + +#include +#include +#include +#include +#include + +static void game_initialize() { + ska_window_initialize((SkaWindowProperties){ + .title = "Hello World!", + .windowWidth = 800, + .windowHeight = 600, + .resolutionWidth = 800, + .resolutionHeight = 600, + .maintainAspectRatio = true, + }); + ska_input_initialize(); +} + +static void game_finalize() { + ska_window_finalize(); + ska_input_finalize(); +} + +static void game_run() { + while (true) { + ska_input_new_frame(); + + bool shouldQuit = false; + SDL_Event event; + while (SDL_PollEvent(&event)) { + switch(event.type) { + case SDL_EVENT_QUIT: + shouldQuit = true; + break; + case SDL_EVENT_WINDOW_RESIZED: { + const Sint32 windowWidth = event.window.data1; + const Sint32 windowHeight = event.window.data2; + ska_renderer_update_window_size(windowWidth, windowHeight); + break; + } + default: { + ska_sdl_process_event(event); + break; + } + } + } + ska_sdl_process_axis_events(); + + if (shouldQuit || ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_ESCAPE, 0)) { + break; + } + ska_window_render(&(SkaColor){ 0.2f, 0.2f, 0.2f, 1.0f }); + SDL_Delay(10); + } +} + +int main(int argv, char** args) { + game_initialize(); + game_run(); + game_finalize(); + return EXIT_SUCCESS; +} From 763b63a95189f5e2b813095455ebcd0909422e33 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Wed, 23 Oct 2024 22:54:23 -0400 Subject: [PATCH 42/55] Clean. --- test/game/src/main.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/test/game/src/main.c b/test/game/src/main.c index 578e11a..b7b6664 100644 --- a/test/game/src/main.c +++ b/test/game/src/main.c @@ -33,9 +33,10 @@ static void game_run() { SDL_Event event; while (SDL_PollEvent(&event)) { switch(event.type) { - case SDL_EVENT_QUIT: + case SDL_EVENT_QUIT: { shouldQuit = true; - break; + break; + } case SDL_EVENT_WINDOW_RESIZED: { const Sint32 windowWidth = event.window.data1; const Sint32 windowHeight = event.window.data2; From 2dbce21f29bad5a43cd1d5e88c49ddff998e4e31 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Thu, 24 Oct 2024 15:47:16 -0400 Subject: [PATCH 43/55] Clean. --- CMakeLists.txt | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index b7a755d..05789dc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -45,8 +45,10 @@ if (SK_IS_MAIN) ${PROJECT_SOURCE_DIR}/test $/test ) - # Create test game executable - add_executable(seika_test_game test/game/src/main.c) - target_link_libraries(seika_test_game seika) + if (SEIKA_INPUT OR SEIKA_RENDERING) + # Create test game executable + add_executable(seika_test_game test/game/src/main.c) + target_link_libraries(seika_test_game seika) + endif () endif() endif() From 980d6f0b017714b7b84d00ddc48093e665ce1796 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Sat, 26 Oct 2024 14:02:23 -0400 Subject: [PATCH 44/55] Updates. --- old_seika/CMakeLists.txt | 41 - old_seika/assert.c | 14 - old_seika/assert.h | 86 - old_seika/asset/asset_file_loader.c | 128 - old_seika/asset/asset_file_loader.h | 46 - old_seika/asset/asset_manager.c | 107 - old_seika/asset/asset_manager.h | 28 - old_seika/audio/audio.c | 70 - old_seika/audio/audio.h | 29 - old_seika/audio/audio_manager.c | 197 - old_seika/audio/audio_manager.h | 18 - old_seika/command_line_args_util.c | 84 - old_seika/command_line_args_util.h | 31 - old_seika/data_structures/array2d.c | 96 - old_seika/data_structures/array2d.h | 20 - old_seika/data_structures/array_list.c | 77 - old_seika/data_structures/array_list.h | 32 - old_seika/data_structures/array_utils.c | 32 - old_seika/data_structures/array_utils.h | 26 - old_seika/data_structures/hash_map.c | 264 - old_seika/data_structures/hash_map.h | 59 - old_seika/data_structures/hash_map_string.c | 295 - old_seika/data_structures/hash_map_string.h | 66 - old_seika/data_structures/linked_list.c | 265 - old_seika/data_structures/linked_list.h | 57 - old_seika/data_structures/queue.c | 60 - old_seika/data_structures/queue.h | 24 - old_seika/data_structures/spatial_hash_map.c | 264 - old_seika/data_structures/spatial_hash_map.h | 43 - old_seika/data_structures/static_array.h | 108 - old_seika/data_structures/tile_map.h | 22 - old_seika/defines.h | 43 - old_seika/ecs/component.c | 191 - old_seika/ecs/component.h | 57 - old_seika/ecs/ec_system.c | 331 - old_seika/ecs/ec_system.h | 110 - old_seika/ecs/ecs.c | 13 - old_seika/ecs/ecs.h | 6 - old_seika/ecs/entity.c | 43 - old_seika/ecs/entity.h | 24 - old_seika/event.c | 47 - old_seika/event.h | 31 - old_seika/file_system.c | 190 - old_seika/file_system.h | 26 - old_seika/flag_utils.h | 24 - old_seika/input/input.c | 567 - old_seika/input/input.h | 292 - old_seika/input/sdl_gamepad_db.h | 41987 ---------------- old_seika/input/sdl_input.h | 333 - old_seika/logger.c | 153 - old_seika/logger.h | 35 - old_seika/macro_utils.h | 4 - old_seika/math/curve_float.c | 93 - old_seika/math/curve_float.h | 33 - old_seika/math/math.c | 176 - old_seika/math/math.h | 180 - old_seika/memory.c | 25 - old_seika/memory.h | 31 - old_seika/networking/network.c | 143 - old_seika/networking/network.h | 24 - old_seika/networking/network_socket.c | 126 - old_seika/networking/network_socket.h | 43 - old_seika/platform.c | 21 - old_seika/platform.h | 25 - old_seika/profile_code.h | 74 - old_seika/rendering/font.c | 132 - old_seika/rendering/font.h | 26 - old_seika/rendering/frame_buffer.c | 181 - old_seika/rendering/frame_buffer.h | 34 - old_seika/rendering/render_context.c | 23 - old_seika/rendering/render_context.h | 16 - old_seika/rendering/renderer.c | 610 - old_seika/rendering/renderer.h | 35 - old_seika/rendering/shader/shader.c | 89 - old_seika/rendering/shader/shader.h | 26 - old_seika/rendering/shader/shader_cache.c | 117 - old_seika/rendering/shader/shader_cache.h | 19 - .../rendering/shader/shader_file_parser.c | 607 - .../rendering/shader/shader_file_parser.h | 28 - old_seika/rendering/shader/shader_instance.c | 197 - old_seika/rendering/shader/shader_instance.h | 72 - .../shader/shader_instance_minimal.h | 8 - old_seika/rendering/shader/shader_source.h | 129 - old_seika/rendering/texture.c | 152 - old_seika/rendering/texture.h | 42 - old_seika/seika.c | 250 - old_seika/seika.h | 38 - old_seika/string.c | 153 - old_seika/string.h | 27 - old_seika/thread/pthread.c | 255 - old_seika/thread/pthread.h | 63 - old_seika/thread/thread_pool.c | 184 - old_seika/thread/thread_pool.h | 32 - old_seika/version_info.h | 9 - seika/version_info.h | 4 +- 95 files changed, 2 insertions(+), 51746 deletions(-) delete mode 100644 old_seika/CMakeLists.txt delete mode 100644 old_seika/assert.c delete mode 100644 old_seika/assert.h delete mode 100644 old_seika/asset/asset_file_loader.c delete mode 100644 old_seika/asset/asset_file_loader.h delete mode 100644 old_seika/asset/asset_manager.c delete mode 100644 old_seika/asset/asset_manager.h delete mode 100644 old_seika/audio/audio.c delete mode 100644 old_seika/audio/audio.h delete mode 100644 old_seika/audio/audio_manager.c delete mode 100644 old_seika/audio/audio_manager.h delete mode 100644 old_seika/command_line_args_util.c delete mode 100644 old_seika/command_line_args_util.h delete mode 100644 old_seika/data_structures/array2d.c delete mode 100644 old_seika/data_structures/array2d.h delete mode 100644 old_seika/data_structures/array_list.c delete mode 100644 old_seika/data_structures/array_list.h delete mode 100644 old_seika/data_structures/array_utils.c delete mode 100644 old_seika/data_structures/array_utils.h delete mode 100644 old_seika/data_structures/hash_map.c delete mode 100644 old_seika/data_structures/hash_map.h delete mode 100644 old_seika/data_structures/hash_map_string.c delete mode 100644 old_seika/data_structures/hash_map_string.h delete mode 100644 old_seika/data_structures/linked_list.c delete mode 100644 old_seika/data_structures/linked_list.h delete mode 100644 old_seika/data_structures/queue.c delete mode 100644 old_seika/data_structures/queue.h delete mode 100644 old_seika/data_structures/spatial_hash_map.c delete mode 100644 old_seika/data_structures/spatial_hash_map.h delete mode 100644 old_seika/data_structures/static_array.h delete mode 100644 old_seika/data_structures/tile_map.h delete mode 100644 old_seika/defines.h delete mode 100644 old_seika/ecs/component.c delete mode 100644 old_seika/ecs/component.h delete mode 100644 old_seika/ecs/ec_system.c delete mode 100644 old_seika/ecs/ec_system.h delete mode 100644 old_seika/ecs/ecs.c delete mode 100644 old_seika/ecs/ecs.h delete mode 100644 old_seika/ecs/entity.c delete mode 100644 old_seika/ecs/entity.h delete mode 100644 old_seika/event.c delete mode 100644 old_seika/event.h delete mode 100644 old_seika/file_system.c delete mode 100644 old_seika/file_system.h delete mode 100644 old_seika/flag_utils.h delete mode 100644 old_seika/input/input.c delete mode 100644 old_seika/input/input.h delete mode 100644 old_seika/input/sdl_gamepad_db.h delete mode 100644 old_seika/input/sdl_input.h delete mode 100644 old_seika/logger.c delete mode 100644 old_seika/logger.h delete mode 100644 old_seika/macro_utils.h delete mode 100644 old_seika/math/curve_float.c delete mode 100644 old_seika/math/curve_float.h delete mode 100644 old_seika/math/math.c delete mode 100644 old_seika/math/math.h delete mode 100644 old_seika/memory.c delete mode 100644 old_seika/memory.h delete mode 100644 old_seika/networking/network.c delete mode 100644 old_seika/networking/network.h delete mode 100644 old_seika/networking/network_socket.c delete mode 100644 old_seika/networking/network_socket.h delete mode 100644 old_seika/platform.c delete mode 100644 old_seika/platform.h delete mode 100644 old_seika/profile_code.h delete mode 100644 old_seika/rendering/font.c delete mode 100644 old_seika/rendering/font.h delete mode 100644 old_seika/rendering/frame_buffer.c delete mode 100644 old_seika/rendering/frame_buffer.h delete mode 100644 old_seika/rendering/render_context.c delete mode 100644 old_seika/rendering/render_context.h delete mode 100644 old_seika/rendering/renderer.c delete mode 100644 old_seika/rendering/renderer.h delete mode 100644 old_seika/rendering/shader/shader.c delete mode 100644 old_seika/rendering/shader/shader.h delete mode 100644 old_seika/rendering/shader/shader_cache.c delete mode 100644 old_seika/rendering/shader/shader_cache.h delete mode 100644 old_seika/rendering/shader/shader_file_parser.c delete mode 100644 old_seika/rendering/shader/shader_file_parser.h delete mode 100644 old_seika/rendering/shader/shader_instance.c delete mode 100644 old_seika/rendering/shader/shader_instance.h delete mode 100644 old_seika/rendering/shader/shader_instance_minimal.h delete mode 100644 old_seika/rendering/shader/shader_source.h delete mode 100644 old_seika/rendering/texture.c delete mode 100644 old_seika/rendering/texture.h delete mode 100644 old_seika/seika.c delete mode 100644 old_seika/seika.h delete mode 100644 old_seika/string.c delete mode 100644 old_seika/string.h delete mode 100644 old_seika/thread/pthread.c delete mode 100644 old_seika/thread/pthread.h delete mode 100644 old_seika/thread/thread_pool.c delete mode 100644 old_seika/thread/thread_pool.h delete mode 100644 old_seika/version_info.h diff --git a/old_seika/CMakeLists.txt b/old_seika/CMakeLists.txt deleted file mode 100644 index c763595..0000000 --- a/old_seika/CMakeLists.txt +++ /dev/null @@ -1,41 +0,0 @@ -cmake_minimum_required(VERSION 3.27.0) - -set(CMAKE_C_STANDARD 11) - -project(seika C) - -if (CMAKE_C_COMPILER_ID STREQUAL "MSVC") - list(APPEND flags "/W3" "/Zc:preprocessor") -elseif (APPLE) - list(APPEND flags "-Wfatal-errors" "-Wall" "-Wextra" "-Wno-write-strings" "-Wno-deprecated-declarations" - "-Wno-unused-variable" "-Wno-bad-function-cast" "-Wno-unused-parameter" "-Wno-missing-field-initializers") -else () - list(APPEND flags "-std=c11" "-Wfatal-errors" "-Wall" "-Wextra" "-Wno-write-strings" "-Wno-deprecated-declarations" - "-Wno-unused-variable" "-Wno-cast-function-type" "-Wno-unused-parameter" "-Wno-missing-field-initializers") -endif () - -file(GLOB_RECURSE SEIKA_SRC ./*.c ./*.h) -add_library(${PROJECT_NAME} STATIC ${SEIKA_SRC}) -target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../) - -#--- Link ---# -if (CMAKE_C_COMPILER_ID STREQUAL "MSVC") - target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio ${SDL3_LIBRARY} freetype Ws2_32) -elseif (WIN32) - target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio -lmingw32 -static-libgcc ${SDL3_LIBRARY} freetype -lws2_32) -elseif (APPLE) - target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio -Xlinker ${SDL3_LIBRARY} freetype m) -else () - target_link_libraries(${PROJECT_NAME} PUBLIC cglm glad stb_image zip miniaudio -static-libgcc -Xlinker -export-dynamic ${SDL3_LIBRARY} freetype m) -endif () - -target_compile_options(${PROJECT_NAME} PUBLIC ${flags}) - -# Copy directories over that are needed to test -if (NOT IS_CI_BUILD) - add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy_directory - ${PROJECT_SOURCE_DIR}/../test - $/../test - ) -endif() diff --git a/old_seika/assert.c b/old_seika/assert.c deleted file mode 100644 index d9161fe..0000000 --- a/old_seika/assert.c +++ /dev/null @@ -1,14 +0,0 @@ -#include "seika/assert.h" - -void ska_print_assert_err(const char* fmt, ...) { -#define SKA_PRINT_BUFFER_SIZE 496 - va_list args; - va_start(args, fmt); - char str[SKA_PRINT_BUFFER_SIZE]; - memset(str, 0, SKA_PRINT_BUFFER_SIZE); - ska_strncat(str, fmt, (sizeof(str) - strlen(str) - 1) ); - ska_strncat(str, "\n", (sizeof(str) - strlen(str) - 1) ); - vfprintf(stderr, str, args); - va_end(args); -#undef SKA_PRINT_BUFFER_SIZE -} diff --git a/old_seika/assert.h b/old_seika/assert.h deleted file mode 100644 index c3c7481..0000000 --- a/old_seika/assert.h +++ /dev/null @@ -1,86 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - - -#include -#include -#include -#include -#include - -#include "defines.h" -#include "platform.h" -#include "seika/string.h" - -#define SKA_ASSERT_FAIL_EXIT_CODE (-1) - -void ska_print_assert_err(const char* fmt, ...); - -#define SKA_ASSERT(PREDICATE) \ -SKA_IF_DEBUG( \ -if (!(PREDICATE)) { \ -ska_print_assert_err("Assertion failed in file '%s' on line %u!\n", __FILE__, __LINE__); \ -if (se_platform_is_debugger_attached()) { SKA_TRIGGER_BREAKPOINT; } \ -exit(SKA_ASSERT_FAIL_EXIT_CODE); \ -} \ -) - -#define SKA_ASSERT_FMT(PREDICATE, FMT, ...) \ -SKA_IF_DEBUG( \ -if (!(PREDICATE)) { \ -ska_print_assert_err("Assertion failed in file '%s' on line %u!", __FILE__, __LINE__); \ -ska_print_assert_err(FMT, ##__VA_ARGS__); \ -if (se_platform_is_debugger_attached()) { SKA_TRIGGER_BREAKPOINT; } \ -exit(SKA_ASSERT_FAIL_EXIT_CODE); \ -} \ -) - -// Non-fatal asserts -#define SKA_ENSURE(PREDICATE) \ -SKA_IF_DEBUG( \ -if (!(PREDICATE)) { \ -static bool hasEnsureTriggered = false; \ -if (!hasEnsureTriggered) { \ -ska_print_assert_err("Ensure failed in file '%s' on line %u!\n", __FILE__, __LINE__); \ -if (se_platform_is_debugger_attached()) { SKA_TRIGGER_BREAKPOINT; } \ -hasEnsureTriggered = true; \ -} \ -} \ -) - -#define SKA_ENSURE_FMT(PREDICATE, FMT, ...) \ -SKA_IF_DEBUG( \ -if (!(PREDICATE)) { \ -static bool hasEnsureTriggered = false; \ -if (!hasEnsureTriggered) { \ -ska_print_assert_err("Ensure failed in file '%s' on line %u!", __FILE__, __LINE__); \ -ska_print_assert_err(FMT, ##__VA_ARGS__); \ -if (se_platform_is_debugger_attached()) { SKA_TRIGGER_BREAKPOINT; } \ -hasEnsureTriggered = true; \ -} \ -} \ -) - -#define SKA_ENSURE_ALWAYS(PREDICATE) \ -SKA_IF_DEBUG( \ -if (!(PREDICATE)) { \ -ska_print_assert_err("Ensure failed in file '%s' on line %u!\n", __FILE__, __LINE__); \ -if (se_platform_is_debugger_attached()) { SKA_TRIGGER_BREAKPOINT; } \ -} \ -) - -#define SKA_ENSURE_ALWAYS_FMT(PREDICATE, FMT, ...) \ -SKA_IF_DEBUG( \ -if (!(PREDICATE)) { \ -ska_print_assert_err("Ensure failed in file '%s' on line %u!", __FILE__, __LINE__); \ -ska_print_assert_err(FMT, ##__VA_ARGS__); \ -if (se_platform_is_debugger_attached()) { SKA_TRIGGER_BREAKPOINT; } \ -} \ -) - -#ifdef __cplusplus -} -#endif diff --git a/old_seika/asset/asset_file_loader.c b/old_seika/asset/asset_file_loader.c deleted file mode 100644 index 513a8da..0000000 --- a/old_seika/asset/asset_file_loader.c +++ /dev/null @@ -1,128 +0,0 @@ -#include "asset_file_loader.h" - -#include -#include - -#include "seika/string.h" -#include "seika/file_system.h" -#include "seika/memory.h" - -SkaAssetFileLoaderReadMode globalReadMode = SkaAssetFileLoaderReadMode_DISK; -struct zip_t* packageArchive = NULL; - -static void clear_package_archive() { - if (packageArchive != NULL) { - zip_entry_close(packageArchive); - packageArchive = NULL; - } -} - -void ska_asset_file_loader_initialize() {} - -void ska_asset_file_loader_finalize() { - clear_package_archive(); -} - -bool ska_asset_file_loader_load_archive(const char* filePath) { - if (ska_fs_does_file_exist(filePath)) { - clear_package_archive(); - packageArchive = zip_open(filePath, 0, 'r'); - return true; - } - return false; -} - -void ska_asset_file_loader_set_read_mode(SkaAssetFileLoaderReadMode readMode) { - globalReadMode = readMode; -} - -SkaAssetFileLoaderReadMode ska_asset_file_loader_get_read_mode() { - return globalReadMode; -} - -SkaArchiveFileAsset ska_asset_file_loader_get_asset(const char* path) { - void* fileBuffer = NULL; - usize fileBufferSize; - zip_entry_open(packageArchive, path); - { - zip_entry_read(packageArchive, &fileBuffer, &fileBufferSize); - } - return (SkaArchiveFileAsset) { - .buffer = fileBuffer, - .bufferSize = fileBufferSize - }; -} - -SkaArchiveFileAsset ska_asset_file_loader_load_asset_from_disk(const char* path) { - SkaArchiveFileAsset asset = {NULL, 0 }; - if (ska_fs_does_file_exist(path)) { - asset.buffer = ska_fs_read_file_contents(path, &asset.bufferSize); - } - return asset; -} - -bool ska_asset_file_loader_is_asset_valid(SkaArchiveFileAsset* fileAsset) { - return fileAsset != NULL && fileAsset->buffer != NULL; -} - -SkaAssetFileImageData* ska_asset_file_loader_load_image_data(const char* filePath) { - SkaAssetFileImageData* imageData = NULL; - stbi_set_flip_vertically_on_load(false); - if (globalReadMode == SkaAssetFileLoaderReadMode_DISK) { - imageData = SKA_MEM_ALLOCATE(SkaAssetFileImageData); - imageData->data = stbi_load(filePath, &imageData->width, &imageData->height, &imageData->nrChannels, 0); - } else if (globalReadMode == SkaAssetFileLoaderReadMode_ARCHIVE) { - SkaArchiveFileAsset fileAsset = ska_asset_file_loader_get_asset(filePath); - if (ska_asset_file_loader_is_asset_valid(&fileAsset)) { - imageData = SKA_MEM_ALLOCATE(SkaAssetFileImageData); - imageData->data = stbi_load_from_memory(fileAsset.buffer, (int32)fileAsset.bufferSize, &imageData->width, &imageData->height, &imageData->nrChannels, 0); - } - } - return imageData; -} - -void ska_asset_file_loader_free_image_data(SkaAssetFileImageData* data) { - stbi_image_free(data->data); - SKA_MEM_FREE(data); -} - -char* ska_asset_file_loader_read_file_contents_as_string(const char* filePath, usize* size) { - char* fileString = NULL; - usize len = 0; - if (globalReadMode == SkaAssetFileLoaderReadMode_DISK) { - if (ska_fs_does_file_exist(filePath)) { - fileString = ska_fs_read_file_contents(filePath, &len); - } - } else if (globalReadMode == SkaAssetFileLoaderReadMode_ARCHIVE) { - SkaArchiveFileAsset fileAsset = ska_asset_file_loader_get_asset(filePath); - if (ska_asset_file_loader_is_asset_valid(&fileAsset)) { - fileString = ska_strdup_from_memory(fileAsset.buffer, fileAsset.bufferSize); - len = fileAsset.bufferSize; - } - } - if (size) { - *size = len; - } - return fileString; -} - -char* ska_asset_file_loader_read_file_contents_as_string_without_raw(const char* filePath, usize* size) { - char* fileString = NULL; - usize len = 0; - if (globalReadMode == SkaAssetFileLoaderReadMode_DISK) { - if (ska_fs_does_file_exist(filePath)) { - fileString = ska_fs_read_file_contents_without_raw(filePath, &len); - } - } else if (globalReadMode == SkaAssetFileLoaderReadMode_ARCHIVE) { - SkaArchiveFileAsset fileAsset = ska_asset_file_loader_get_asset(filePath); - if (ska_asset_file_loader_is_asset_valid(&fileAsset)) { - fileString = ska_strdup_from_memory(fileAsset.buffer, fileAsset.bufferSize); - ska_str_remove_char(fileString, '\r'); - len = fileAsset.bufferSize; - } - } - if (size) { - *size = len; - } - return fileString; -} diff --git a/old_seika/asset/asset_file_loader.h b/old_seika/asset/asset_file_loader.h deleted file mode 100644 index 5598427..0000000 --- a/old_seika/asset/asset_file_loader.h +++ /dev/null @@ -1,46 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -#include -#include - -#include "seika/defines.h" - -typedef enum SkaAssetFileLoaderReadMode { - SkaAssetFileLoaderReadMode_DISK, - SkaAssetFileLoaderReadMode_ARCHIVE, -} SkaAssetFileLoaderReadMode; - -typedef struct SkaArchiveFileAsset { - void* buffer; - usize bufferSize; -} SkaArchiveFileAsset; - -typedef struct SkaAssetFileImageData { - unsigned char* data; - int32 width; - int32 height; - int32 nrChannels; -} SkaAssetFileImageData; - -void ska_asset_file_loader_initialize(); -void ska_asset_file_loader_finalize(); -bool ska_asset_file_loader_load_archive(const char* filePath); -void ska_asset_file_loader_set_read_mode(SkaAssetFileLoaderReadMode readMode); -SkaAssetFileLoaderReadMode ska_asset_file_loader_get_read_mode(); -SkaArchiveFileAsset ska_asset_file_loader_get_asset(const char* path); -SkaArchiveFileAsset ska_asset_file_loader_load_asset_from_disk(const char* path); -bool ska_asset_file_loader_is_asset_valid(SkaArchiveFileAsset* fileAsset); - -// Asset loading types -SkaAssetFileImageData* ska_asset_file_loader_load_image_data(const char* filePath); -void ska_asset_file_loader_free_image_data(SkaAssetFileImageData* data); -char* ska_asset_file_loader_read_file_contents_as_string(const char* filePath, usize* size); -char* ska_asset_file_loader_read_file_contents_as_string_without_raw(const char* filePath, usize* size); - -#ifdef __cplusplus -} -#endif diff --git a/old_seika/asset/asset_manager.c b/old_seika/asset/asset_manager.c deleted file mode 100644 index ab739db..0000000 --- a/old_seika/asset/asset_manager.c +++ /dev/null @@ -1,107 +0,0 @@ -#include "asset_manager.h" - -#include "seika/memory.h" -#include "seika/assert.h" -#include "seika/data_structures/hash_map_string.h" -#include "seika/rendering/texture.h" -#include "seika/rendering/font.h" -#include "seika/audio/audio.h" - -static SkaStringHashMap* texturesMap = NULL; -static SkaStringHashMap* fontMap = NULL; -static SkaStringHashMap* audioSourceMap = NULL; - -void ska_asset_manager_initialize() { - texturesMap = ska_string_hash_map_create_default_capacity(); - fontMap = ska_string_hash_map_create_default_capacity(); - audioSourceMap = ska_string_hash_map_create_default_capacity(); -} - -void ska_asset_manager_finalize() { - ska_string_hash_map_destroy(texturesMap); - ska_string_hash_map_destroy(fontMap); - ska_string_hash_map_destroy(audioSourceMap); -} - -// --- Texture --- // -SkaTexture* ska_asset_manager_load_texture(const char* fileName, const char* key) { - SKA_ASSERT(texturesMap != NULL); - SKA_ASSERT_FMT(!ska_string_hash_map_has(texturesMap, fileName), "Already loaded texture at file path '%'s! Has key '%s'.", fileName, key); - SkaTexture* texture = ska_texture_create_texture(fileName); - ska_string_hash_map_add(texturesMap, key, texture, sizeof(SkaTexture)); - SKA_MEM_FREE(texture); - texture = (SkaTexture*) ska_string_hash_map_get(texturesMap, key); - return texture; -} - -SkaTexture* ska_asset_manager_load_texture_ex(const char* fileName, const char* key, const char* wrap_s, const char* wrap_t, bool applyNearestNeighbor) { - SKA_ASSERT(texturesMap != NULL); - SKA_ASSERT_FMT(!ska_string_hash_map_has(texturesMap, fileName), "Already loaded texture at file path '%'s! Has key '%s'.", fileName, key); - SkaTexture* texture = ska_texture_create_texture2( - fileName, - ska_texture_wrap_string_to_int(wrap_s), - ska_texture_wrap_string_to_int(wrap_t), - applyNearestNeighbor - ); - ska_string_hash_map_add(texturesMap, key, texture, sizeof(SkaTexture)); - SKA_MEM_FREE(texture); - texture = (SkaTexture*) ska_string_hash_map_get(texturesMap, key); - return texture; -} - -SkaTexture* ska_asset_manager_get_texture(const char* key) { - return (SkaTexture*) ska_string_hash_map_get(texturesMap, key); -} - -bool ska_asset_manager_has_texture(const char* key) { - return ska_string_hash_map_has(texturesMap, key); -} - -// --- Font --- // -SkaFont* ska_asset_manager_load_font(const char* fileName, const char* key, int size, bool applyNearestNeighbor) { - SKA_ASSERT_FMT(!ska_asset_manager_has_font(key), "Font key '%s' already exists!", key); - SkaFont* font = ska_font_create_font(fileName, size, applyNearestNeighbor); - SKA_ASSERT_FMT(font != NULL, "Failed to load font! file_name: '%s', key: '%s', size: '%d'", fileName, key, size); - ska_string_hash_map_add(fontMap, key, font, sizeof(SkaFont)); - SKA_MEM_FREE(font); - font = (SkaFont*) ska_string_hash_map_get(fontMap, key); - return font; -} - -SkaFont* ska_asset_manager_load_font_from_memory(const char* key, void* buffer, usize bufferSize, int size, bool applyNearestNeighbor) { - SKA_ASSERT_FMT(!ska_asset_manager_has_font(key), "Font key '%s' already exists!", key); - SkaFont* font = ska_font_create_font_from_memory(buffer, bufferSize, size, applyNearestNeighbor); - SKA_ASSERT_FMT(font != NULL, "Failed to load font! key: '%s', size: '%d'", key, size); - ska_string_hash_map_add(fontMap, key, font, sizeof(SkaFont)); - SKA_MEM_FREE(font); - font = (SkaFont*) ska_string_hash_map_get(fontMap, key); - return font; -} - - -SkaFont* ska_asset_manager_get_font(const char* key) { - return (SkaFont*) ska_string_hash_map_get(fontMap, key); -} - -bool ska_asset_manager_has_font(const char* key) { - return ska_string_hash_map_has(fontMap, key); -} - -// --- Audio Source --- // -SkaAudioSource* ska_asset_manager_load_audio_source_wav(const char* fileName, const char* key) { - SKA_ASSERT(audioSourceMap != NULL); - SKA_ASSERT_FMT(!ska_string_hash_map_has(audioSourceMap, fileName), "Already loaded audio source at file path '%'s! Has key '%s'.", fileName, key); - SkaAudioSource* newAudioSource = ska_audio_load_audio_source_wav(fileName); - SKA_ASSERT_FMT(newAudioSource != NULL, "Audio source is null! file_name = '%s', key = '%s'", fileName, key); - ska_string_hash_map_add(audioSourceMap, key, newAudioSource, sizeof(SkaAudioSource)); - SKA_MEM_FREE(newAudioSource); - return newAudioSource; -} - -SkaAudioSource* ska_asset_manager_get_audio_source(const char* key) { - return (SkaAudioSource*) ska_string_hash_map_get(audioSourceMap, key); -} - -bool ska_asset_manager_has_audio_source(const char* key) { - return ska_string_hash_map_has(audioSourceMap, key); -} diff --git a/old_seika/asset/asset_manager.h b/old_seika/asset/asset_manager.h deleted file mode 100644 index c9f1bf2..0000000 --- a/old_seika/asset/asset_manager.h +++ /dev/null @@ -1,28 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -#include "seika/defines.h" - -void ska_asset_manager_initialize(); -void ska_asset_manager_finalize(); -// --- Texture --- // -struct SkaTexture* ska_asset_manager_load_texture(const char* fileName, const char* key); -struct SkaTexture* ska_asset_manager_load_texture_ex(const char* fileName, const char* key, const char* wrap_s, const char* wrap_t, bool applyNearestNeighbor); -struct SkaTexture* ska_asset_manager_get_texture(const char* key); -bool ska_asset_manager_has_texture(const char* key); -// --- Font --- // -struct SkaFont* ska_asset_manager_load_font(const char* fileName, const char* key, int size, bool applyNearestNeighbor); -struct SkaFont* ska_asset_manager_load_font_from_memory(const char* key, void* buffer, usize bufferSize, int size, bool applyNearestNeighbor); -struct SkaFont* ska_asset_manager_get_font(const char* key); -bool ska_asset_manager_has_font(const char* key); -// -- Audio Source --- // -struct SkaAudioSource* ska_asset_manager_load_audio_source_wav(const char* fileName, const char* key); -struct SkaAudioSource* ska_asset_manager_get_audio_source(const char* key); -bool ska_asset_manager_has_audio_source(const char* key); - -#ifdef __cplusplus -} -#endif diff --git a/old_seika/audio/audio.c b/old_seika/audio/audio.c deleted file mode 100644 index 635a1c9..0000000 --- a/old_seika/audio/audio.c +++ /dev/null @@ -1,70 +0,0 @@ -#include "audio.h" - -#define MINIAUDIO_IMPLEMENTATION -#include - -#include "seika/memory.h" -#include "seika/logger.h" -#include "seika/asset/asset_file_loader.h" - -static uint32 audioWavSampleRate = SKA_AUDIO_SOURCE_DEFAULT_WAV_SAMPLE_RATE; - -static bool load_wav_data_from_file(const char* file_path, int32* sample_count, int32* channels, int32* sample_rate, void** samples); - -void ska_audio_print_audio_source(SkaAudioSource* audioSource) { - ska_logger_debug("audio source | channels = %d, sample rate = %d, sample count = %d, samples = %x", - audioSource->channels, audioSource->sample_rate, audioSource->sample_count, audioSource->samples); -} - -void ska_audio_set_wav_sample_rate(uint32 wavSampleRate) { - audioWavSampleRate = wavSampleRate; -} - -uint32_t ska_audio_get_wav_sample_rate() { - return audioWavSampleRate; -} - -SkaAudioSource* ska_audio_load_audio_source_wav(const char* fileName) { - int32_t sampleCount; - int32_t channels; - int32_t sampleRate; - void* samples = NULL; - if (!load_wav_data_from_file(fileName, &sampleCount, &channels, &sampleRate, &samples)) { - ska_logger_error("Failed to load audio wav file at '%s'", fileName); - return NULL; - } - SkaAudioSource* newAudioSource = (SkaAudioSource*)SKA_MEM_ALLOCATE_SIZE(sizeof(SkaAudioSource*) + (sampleCount * sizeof(int16_t*))); - newAudioSource->file_path = fileName; - newAudioSource->pitch = 1.0; - newAudioSource->sample_count = sampleCount; - newAudioSource->channels = channels; - newAudioSource->sample_rate = sampleRate; - newAudioSource->samples = samples; - - if ((uint32_t)newAudioSource->sample_rate != audioWavSampleRate) { - ska_logger_error("Sample rate for wav file '%s' is %d instead of the expected sample rate of %d! Audio won't play as expected!", - fileName, sampleRate, audioWavSampleRate); - } - - return newAudioSource; -} - -bool load_wav_data_from_file(const char* file_path, int32_t* sample_count, int32_t* channels, int32_t* sample_rate, void** samples) { - usize len = 0; - char* file_data = ska_asset_file_loader_read_file_contents_as_string(file_path, &len); - ska_logger_debug("file '%s' size '%u' bytes", file_path, len); - - drwav_uint64 totalPcmFrameCount = 0; - *samples = drwav_open_memory_and_read_pcm_frames_s16(file_data, len, (uint32_t*)channels, (uint32_t*)sample_rate, &totalPcmFrameCount, NULL); - SKA_MEM_FREE(file_data); - - if (!*samples) { - *samples = NULL; - ska_logger_error("Could not load .wav file: %s", file_path); - return false; - } - - *sample_count = (int32_t) totalPcmFrameCount * *channels; - - return true; -} diff --git a/old_seika/audio/audio.h b/old_seika/audio/audio.h deleted file mode 100644 index 48f0db2..0000000 --- a/old_seika/audio/audio.h +++ /dev/null @@ -1,29 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#include "seika/defines.h" - -#define SKA_AUDIO_SOURCE_DEFAULT_WAV_SAMPLE_RATE 44100 - -typedef struct SkaAudioSource { - const char* file_path; - f64 pitch; - int32 channels; - int32 sample_rate; - void* samples; - int32 sample_count; -} SkaAudioSource; - -void ska_audio_print_audio_source(SkaAudioSource* audioSource); -void ska_audio_set_wav_sample_rate(uint32 wavSampleRate); -uint32 ska_audio_get_wav_sample_rate(); -SkaAudioSource* ska_audio_load_audio_source_wav(const char* fileName); - -#ifdef __cplusplus -} -#endif diff --git a/old_seika/audio/audio_manager.c b/old_seika/audio/audio_manager.c deleted file mode 100644 index 7da5ee4..0000000 --- a/old_seika/audio/audio_manager.c +++ /dev/null @@ -1,197 +0,0 @@ -#include "audio_manager.h" - -#include -#include - -#include - -#include "audio.h" -#include "seika/memory.h" -#include "seika/logger.h" -#include "seika/assert.h" -#include "seika/asset/asset_manager.h" -#include "seika/thread/pthread.h" - -#define SKA_MAX_AUDIO_INSTANCES 32 - -static void audio_data_callback(ma_device* device, void* output, const void* input, ma_uint32 frame_count); - -static ma_device* audio_device = NULL; -static pthread_mutex_t audio_mutex; - -// An instance of an RBE audio source -typedef struct SkaAudioInstance { - SkaAudioSource* source; - uint32 id; - bool is_playing; - bool does_loop; - f64 sample_position; -} SkaAudioInstance; - -typedef struct SkaAudioInstances { - SkaAudioInstance* instances[SKA_MAX_AUDIO_INSTANCES]; - usize count; -} SkaAudioInstances; - -static SkaAudioInstances* audio_instances = NULL; - -// --- Audio Manager --- // -bool ska_audio_manager_init(uint32 wavSampleRate) { - audio_instances = SKA_MEM_ALLOCATE(SkaAudioInstances); - pthread_mutex_init(&audio_mutex, NULL); - ska_audio_set_wav_sample_rate(wavSampleRate); - // Device - ma_device_config config = ma_device_config_init(ma_device_type_playback); - config.playback.pDeviceID = NULL; - config.playback.format = ma_format_s16; - config.playback.channels = 2; - config.capture.pDeviceID = NULL; - config.capture.format = ma_format_s16; - config.capture.channels = 1; - config.sampleRate = wavSampleRate; - config.dataCallback = audio_data_callback; - config.pUserData = NULL; - audio_device = SKA_MEM_ALLOCATE(ma_device); - if (ma_device_init(NULL, &config, audio_device) != MA_SUCCESS) { - ska_logger_error("Failed to initialize miniaudio device!"); - return false; - } - - if (ma_device_start(audio_device) != MA_SUCCESS) { - ska_logger_error("Failed to start audio device!"); - return false; - } - - return true; -} - -void ska_audio_manager_finalize() { - ma_device_uninit(audio_device); - SKA_MEM_FREE(audio_device); - audio_device = NULL; - - SKA_MEM_FREE(audio_instances); // TODO: Properly free up all instances - audio_instances = NULL; - - pthread_mutex_destroy(&audio_mutex); -} - -void ska_audio_manager_play_sound(const char* filePath, bool loops) { - if (!ska_asset_manager_has_audio_source(filePath)) { - ska_logger_error("Doesn't have audio source loaded at path '%s' loaded! Aborting...", filePath); - return; - } else if (audio_instances->count >= SKA_MAX_AUDIO_INSTANCES) { - ska_logger_warn("Reached max audio instances of '%d', not playing sound!", SKA_MAX_AUDIO_INSTANCES); - return; - } - - pthread_mutex_lock(&audio_mutex); - // Create audio instance and add to instances array - static unsigned int audioInstanceId = 0; // TODO: temp id for now in case we need to grab a hold of an audio instance for roll back later... - SkaAudioInstance* audioInstance = SKA_MEM_ALLOCATE(SkaAudioInstance); - audioInstance->source = ska_asset_manager_get_audio_source(filePath); - audioInstance->id = audioInstanceId++; - audioInstance->does_loop = loops; - audioInstance->sample_position = 0.0f; - audioInstance->is_playing = true; // Sets sound instance to be played - - audio_instances->instances[audio_instances->count++] = audioInstance; - ska_logger_debug("Added audio instance from file path '%s' to play!", filePath); - pthread_mutex_unlock(&audio_mutex); -} - -void ska_audio_manager_stop_sound(const char* filePath) { - pthread_mutex_lock(&audio_mutex); - for (usize i = 0; i < audio_instances->count; i++) { - SkaAudioInstance* audioInst = audio_instances->instances[i]; - if (strcmp(audioInst->source->file_path, filePath) == 0) { - audioInst->is_playing = false; - break; - } - } - pthread_mutex_unlock(&audio_mutex); -} - -// --- Mini Audio Callback --- // -void audio_data_callback(ma_device* device, void* output, const void* input, ma_uint32 frame_count) { - if (audio_instances->count <= 0) { - return; - } - - pthread_mutex_lock(&audio_mutex); - memset(output, 0, frame_count * device->playback.channels * ma_get_bytes_per_sample(device->playback.format)); - usize removedInstances = 0; - for (usize i = 0; i < audio_instances->count; i++) { - SkaAudioInstance* audioInst = audio_instances->instances[i]; - SKA_ASSERT_FMT(audioInst != NULL, "audio instance with index %zu is null!", i); - if (!audioInst->is_playing) { - SKA_MEM_FREE(audioInst); - audio_instances->instances[i] = NULL; - removedInstances++; - continue; - } - - const int32_t channels = audioInst->source->channels; - const f64 pitch = audioInst->source->pitch; - int16* sampleOut = (int16*) output; - int16* samples = (int16*) audioInst->source->samples; - uint64_t samplesToWrite = (uint64_t) frame_count; - - // Write to output - for (uint64_t writeSample = 0; writeSample < samplesToWrite; writeSample++) { - f64 startSamplePosition = audioInst->sample_position; - - f64 targetSamplePosition = startSamplePosition + (f64)channels * pitch; - if (targetSamplePosition >= audioInst->source->sample_count) { - targetSamplePosition -= (f64)audioInst->source->sample_count; - } - - uint64 leftId = (uint64) startSamplePosition; - if (channels > 1) { - leftId &= ~((uint64)(0x01)); - } - const uint64 rightId = leftId + (uint64)(channels - 1); - const int16 startLeftSample = samples[leftId + channels]; - const int16 startRightSample = samples[rightId + channels]; - - const int16 leftSample = (int16)(startLeftSample / channels); - const int16 rightSample = (int16)(startRightSample / channels); - - *sampleOut++ += leftSample; // Left - *sampleOut++ += rightSample; // Right - - // Possibly need fixed sampling instead - audioInst->sample_position = targetSamplePosition; - - const bool isAtEnd = audioInst->sample_position >= audioInst->source->sample_count - channels - 1; - if (isAtEnd) { - audioInst->sample_position = 0; - if (!audioInst->does_loop) { - ska_logger_debug("Audio instance with id '%u' is queued for deletion!", audioInst->id); - audio_instances->instances[i] = NULL; - removedInstances++; - SKA_MEM_FREE(audioInst); - break; - } - } - } - } - - // Reshuffle array and update count if data sources have been removed - if (removedInstances > 0) { - static SkaAudioInstance* tempAudioInstances[SKA_MAX_AUDIO_INSTANCES]; - usize newCount = 0; - // Place non-null instances in temp array - for (usize i = 0; i < audio_instances->count; i++) { - if (audio_instances->instances[i] != NULL) { - tempAudioInstances[newCount++] = audio_instances->instances[i]; - } - } - // Now fill up regular array - for (usize i = 0; i < newCount; i++) { - audio_instances->instances[i] = tempAudioInstances[i]; - } - audio_instances->count = newCount; - } - pthread_mutex_unlock(&audio_mutex); -} diff --git a/old_seika/audio/audio_manager.h b/old_seika/audio/audio_manager.h deleted file mode 100644 index a9a7484..0000000 --- a/old_seika/audio/audio_manager.h +++ /dev/null @@ -1,18 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -#include "seika/defines.h" - -// --- Audio Manager --- // -bool ska_audio_manager_init(uint32 wavSampleRate); -void ska_audio_manager_finalize(); -// Process current jobs for resource manager -void ska_audio_manager_play_sound(const char* filePath, bool loops); -void ska_audio_manager_stop_sound(const char* filePath); - -#ifdef __cplusplus -} -#endif diff --git a/old_seika/command_line_args_util.c b/old_seika/command_line_args_util.c deleted file mode 100644 index caf044a..0000000 --- a/old_seika/command_line_args_util.c +++ /dev/null @@ -1,84 +0,0 @@ -#include "command_line_args_util.h" - -#include -#include -#include - -#include "seika/data_structures/hash_map_string.h" - -static SkaStringHashMap* ska_cmd_line_args_get_key_to_arg_def_map(SKACmdLineArgDef* argDefs) { - SkaStringHashMap* keyToArgDefMap = ska_string_hash_map_create_default_capacity(); - for (usize i = 0; i < 999999999; i++) { - if (argDefs[i].id == NULL) { - break; - } - - SKACmdLineArgDef* argDef = &argDefs[i]; - for (usize argIndex = 0; argIndex < SKA_COMMAND_LINE_ARGS_KEY_LIMIT; argIndex++) { - const char* argKey = argDef->keys[argIndex]; - if (!argKey) { - break; - } - - ska_string_hash_map_add(keyToArgDefMap, argKey, argDef, sizeof(SKACmdLineArgDef)); - } - } - - return keyToArgDefMap; -} - -SKACmdLineArgKeyResult* ska_cmd_line_args_util_find_or_add_key_result(const SKACmdLineArgDef* argDef, SKACmdLineArgResult* result) { - for (usize i = 0; i < result->keyResultCount; i++) { - SKACmdLineArgKeyResult* keyResult = &result->keyResults[i]; - for (usize j = 0; j < SKA_COMMAND_LINE_ARGS_KEY_LIMIT; j++) { - if (!argDef->keys[j]) { - break; - } - - if (strcmp(keyResult->id, argDef->id) == 0) { - return keyResult; - } - } - } - - // If here, we don't have a key result so add one - SKACmdLineArgKeyResult* keyResult = &result->keyResults[result->keyResultCount++]; - keyResult->id = argDef->id; - - return keyResult; -} - -SKACmdLineArgResult ska_cmd_line_args_util_parse(int32 argv, char** args, SKACmdLineArgDef* argDefs) { - SKACmdLineArgResult result = (SKACmdLineArgResult){0}; - SkaStringHashMap* keyToArgDefMap = ska_cmd_line_args_get_key_to_arg_def_map(argDefs); - - for (int32 i = 0; i < argv; i++) { - const char* arg = args[i]; - const SKACmdLineArgDef* argDef = (SKACmdLineArgDef*)ska_string_hash_map_find(keyToArgDefMap, arg); - if (argDef) { - SKACmdLineArgKeyResult* keyResult = ska_cmd_line_args_util_find_or_add_key_result(argDef, &result); - if (argDef->expectsValue) { - const int32 nextArgIndex = i + 1; - if (nextArgIndex < argv) { - keyResult->values[keyResult->valueCount++] = args[nextArgIndex]; - } - } - } - } - - ska_string_hash_map_destroy(keyToArgDefMap); - - return result; -} - -void ska_cmd_line_args_util_print_results(const SKACmdLineArgResult* result) { - for (usize i = 0; i < result->keyResultCount; i++) { - const SKACmdLineArgKeyResult* keyResult = &result->keyResults[i]; - printf("---------------------------------------------------------------\n"); - printf("Key Id: '%s'\n", keyResult->id); - for (usize valueIndex = 0; valueIndex < keyResult->valueCount; valueIndex++) { - printf("Value: '%s'\n", keyResult->values[valueIndex]); - } - printf("---------------------------------------------------------------\n"); - } -} diff --git a/old_seika/command_line_args_util.h b/old_seika/command_line_args_util.h deleted file mode 100644 index 68c0d61..0000000 --- a/old_seika/command_line_args_util.h +++ /dev/null @@ -1,31 +0,0 @@ -#pragma once - -#include -#include - -#include "seika/defines.h" - -#define SKA_COMMAND_LINE_ARGS_KEY_LIMIT 8 -#define SKA_COMMAND_LINE_ARGS_RETURN_LIMIT 8 -#define SKA_COMMAND_LINE_ARGS_RETURN_VALUES_LIMIT 8 - -typedef struct SKACmdLineArgDef { - const char* id; - const char* description; - bool expectsValue; - const char* keys[SKA_COMMAND_LINE_ARGS_KEY_LIMIT]; -} SKACmdLineArgDef; - -typedef struct SKACmdLineArgKeyResult { - const char* id; - const char* values[SKA_COMMAND_LINE_ARGS_RETURN_VALUES_LIMIT]; - usize valueCount; -} SKACmdLineArgKeyResult; - -typedef struct SKACmdLineArgResult { - SKACmdLineArgKeyResult keyResults[SKA_COMMAND_LINE_ARGS_RETURN_LIMIT]; - usize keyResultCount; -} SKACmdLineArgResult; - -SKACmdLineArgResult ska_cmd_line_args_util_parse(int32 argv, char** args, SKACmdLineArgDef* argDefs); -void ska_cmd_line_args_util_print_results(const SKACmdLineArgResult* result); diff --git a/old_seika/data_structures/array2d.c b/old_seika/data_structures/array2d.c deleted file mode 100644 index cd7d3ed..0000000 --- a/old_seika/data_structures/array2d.c +++ /dev/null @@ -1,96 +0,0 @@ -#include "array2d.h" - -#include - -#include "seika/memory.h" -#include "seika/assert.h" - -#define SKA_ARRAY2D_IS_COORD_INVALID(ARRAY2D, ROW, COL) ((int32)ROW >= ARRAY2D->size.w || (int32)COL >= ARRAY2D->size.h) - -SkaArray2D* ska_array2d_create(usize rows, usize cols, usize elementSize) { - SkaArray2D* newArray = SKA_MEM_ALLOCATE(SkaArray2D); - newArray->data = SKA_MEM_ALLOCATE_SIZE(cols * sizeof(void*)); - for (usize i = 0; i < cols; i++) { - newArray->data[i] = SKA_MEM_ALLOCATE_SIZE(rows * elementSize); - } - newArray->size = (SkaSize2Di){ .w = (int32)rows, .h = (int32)cols }; - newArray->elementSize = elementSize; - return newArray; -} - -void ska_array2d_destroy(SkaArray2D* array2d) { - for (int32 i = 0; i < array2d->size.h; i++) { - SKA_MEM_FREE(array2d->data[i]); - } - SKA_MEM_FREE(array2d->data); - SKA_MEM_FREE(array2d); -} - -void* ska_array2d_get(SkaArray2D* array2d, usize x, usize y) { - if (SKA_ARRAY2D_IS_COORD_INVALID(array2d, x, y)) { - return NULL; - } - return (void*)((char*)array2d->data[y] + x * array2d->elementSize); -} - -bool ska_array2d_set(SkaArray2D* array2d, usize x, usize y, void* newValue) { - if (SKA_ARRAY2D_IS_COORD_INVALID(array2d, x, y)) { - return false; - } - memcpy((void*)((char*)array2d->data[y] + x * array2d->elementSize), newValue, array2d->elementSize); - return true; -} - -void ska_array2d_resize(SkaArray2D* array2d, usize newX, usize newY) { - // Reallocate memory for data array - const usize newWidth = SKA_MATH_MAX(newX, 1); - const usize newHeight = SKA_MATH_MAX(newY, 1); - // Cache off old data - void** oldData = array2d->data; - const SkaSize2Di oldSize = array2d->size; - // Allocate data for all columns - array2d->data = SKA_MEM_ALLOCATE_SIZE(newHeight * sizeof(void*)); - // Iterate over new rows - for (usize i = 0; i < newHeight; i++) { - // Allocate data for new row - array2d->data[i] = SKA_MEM_ALLOCATE_SIZE(newX * array2d->elementSize); - if (i < (usize)oldSize.h) { - // Now copy old data - const usize bytesToCopy = SKA_MATH_MIN((usize)oldSize.w, newWidth) * array2d->elementSize; - memcpy(array2d->data[i], oldData[i], bytesToCopy); - } - } - - array2d->size = (SkaSize2Di){ .w = (int32)newX, .h = (int32)newY }; - - if (newX == 0 && newY == 0) { - ska_array2d_reset(array2d); - } - - for (usize i = 0; i < (usize)oldSize.h; i++) { - SKA_MEM_FREE(oldData[i]); - } - SKA_MEM_FREE(oldData); -} - -void ska_array2d_clear(SkaArray2D* array2d) { - ska_array2d_resize(array2d, 0, 0); -} - -void ska_array2d_reset(SkaArray2D* array2d) { - ska_array2d_reset_default(array2d, NULL); -} - -void ska_array2d_reset_default(SkaArray2D* array2d, void* defaultValue) { - if (defaultValue) { - for (int32 y = 0; y < array2d->size.h; y++) { - for (int32 x = 0; x < array2d->size.w; x++) { - ska_array2d_set(array2d, x, y, defaultValue); - } - } - } else { - for (int32 i = 0; i < array2d->size.h; i++) { - memset(array2d->data[i], 0, array2d->size.w * array2d->elementSize); - } - } -} diff --git a/old_seika/data_structures/array2d.h b/old_seika/data_structures/array2d.h deleted file mode 100644 index f2c9cc0..0000000 --- a/old_seika/data_structures/array2d.h +++ /dev/null @@ -1,20 +0,0 @@ -#pragma once - -#include "seika/math/math.h" - -typedef struct SkaArray2D { - void** data; - SkaSize2Di size; // w = rows, h = columns - usize elementSize; -} SkaArray2D; - -SkaArray2D* ska_array2d_create(usize rows, usize cols, usize elementSize); -void ska_array2d_destroy(SkaArray2D* array2d); -void* ska_array2d_get(SkaArray2D* array2d, usize x, usize y); -bool ska_array2d_set(SkaArray2D* array2d, usize x, usize y, void* newValue); -void ska_array2d_resize(SkaArray2D* array2d, usize newX, usize newY); -void ska_array2d_clear(SkaArray2D* array2d); -// Maintains elements in the arrays but zeroes out data -void ska_array2d_reset(SkaArray2D* array2d); -// Maintains elements in the arrays but copy memory from the passed in default value -void ska_array2d_reset_default(SkaArray2D* array2d, void* defaultValue); diff --git a/old_seika/data_structures/array_list.c b/old_seika/data_structures/array_list.c deleted file mode 100644 index 0e94f17..0000000 --- a/old_seika/data_structures/array_list.c +++ /dev/null @@ -1,77 +0,0 @@ -#include "array_list.h" - -#include - -#include "seika/memory.h" -#include "seika/assert.h" - -#define SKA_ARRAY_LIST_DEFAULT_CAPACITY 16 - -SkaArrayList* ska_array_list_create_default_capacity(usize valueSize) { - return ska_array_list_create(valueSize, SKA_ARRAY_LIST_DEFAULT_CAPACITY); -} - -SkaArrayList* ska_array_list_create(usize valueSize, usize initialCapacity) { - SkaArrayList* newList = SKA_MEM_ALLOCATE(SkaArrayList); - newList->data = SKA_MEM_ALLOCATE_SIZE(initialCapacity * valueSize); - newList->valueSize = valueSize; - newList->capacity = initialCapacity; - newList->initialCapacity = initialCapacity; - return newList; -} - -void ska_array_list_destroy(SkaArrayList* list) { - SKA_MEM_FREE(list->data); - SKA_MEM_FREE(list); -} - -void ska_array_list_push_back(SkaArrayList* list, const void* value) { - if (list->size >= list->capacity) { - list->capacity *= 2; - list->data = ska_mem_reallocate(list->data, list->capacity * list->valueSize); - } - memcpy((char*)list->data + list->size * list->valueSize, value, list->valueSize); - list->size++; -} - -void* ska_array_list_get(SkaArrayList* list, usize index) { - SKA_ASSERT_FMT(index < list->size, "Attempting to access out of bounds index '%d", index); - return (char*)list->data + index * list->valueSize; -} - -bool ska_array_list_remove(SkaArrayList* list, const void* value) { - usize index = 0; - while (index < list->size) { - if (memcmp((char*)list->data + index * list->valueSize, value, list->valueSize) == 0) { - // Found the element, remove it - for (usize i = index + 1; i < list->size; ++i) { - memcpy((char*)list->data + (i - 1) * list->valueSize, (char*)list->data + i * list->valueSize, list->valueSize); - } - list->size--; - return true; - } else { - index++; - } - } - return false; -} - -bool ska_array_list_remove_by_index(SkaArrayList* list, usize index) { - if (index < list->size) { - // Shift elements after the removed element - for (usize i = index + 1; i < list->size; ++i) { - memcpy((char*)list->data + (i - 1) * list->valueSize, (char*)list->data + i * list->valueSize, list->valueSize); - } - list->size--; - return true; - } - return false; -} - -bool ska_array_list_is_empty(SkaArrayList *list) { - return list->size == 0; -} - -void ska_array_list_clear(SkaArrayList *list) { - list->size = 0; -} diff --git a/old_seika/data_structures/array_list.h b/old_seika/data_structures/array_list.h deleted file mode 100644 index d03a6ff..0000000 --- a/old_seika/data_structures/array_list.h +++ /dev/null @@ -1,32 +0,0 @@ -#pragma once - -#include "seika/defines.h" - -#define SKA_ARRAY_LIST_GET_ARRAY(LIST, TYPE) ((TYPE*)((LIST)->data)) -#define SKA_ARRAY_LIST_FOR_EACH(LIST, TYPE, VALUE) for(TYPE* VALUE = SKA_ARRAY_LIST_GET_ARRAY(LIST, TYPE), *VALUE##_end = VALUE + (LIST)->size; VALUE < VALUE##_end; VALUE++) - -// Generic array list, use 'ska_array_list_create' to allocate on the heap -typedef struct SkaArrayList { - void* data; - usize valueSize; // Size of each element of the data - usize size; // How many elements are in the array - usize capacity; // Max elements allowed in array before resizing - usize initialCapacity; // Min capacity for the array list -} SkaArrayList; - -// Will create a new array list with all it's element values set to the passed in 'valueSize' -SkaArrayList* ska_array_list_create_default_capacity(usize valueSize); -SkaArrayList* ska_array_list_create(usize valueSize, usize initialCapacity); -// Will complete destroy the array list freeing up all its memory -void ska_array_list_destroy(SkaArrayList* list); -// Inserts an item at the end of the list -void ska_array_list_push_back(SkaArrayList* list, const void* value); -// Returns an item from the list from specified index -void* ska_array_list_get(SkaArrayList* list, usize index); -// Removes the first item from the list who is equal to the passed in value -bool ska_array_list_remove(SkaArrayList* list, const void* value); -bool ska_array_list_remove_by_index(SkaArrayList* list, usize index); -// Returns true if the array list size == 0 -bool ska_array_list_is_empty(SkaArrayList *list); -// Will remove all items from the array list -void ska_array_list_clear(SkaArrayList *list); diff --git a/old_seika/data_structures/array_utils.c b/old_seika/data_structures/array_utils.c deleted file mode 100644 index 5eafadf..0000000 --- a/old_seika/data_structures/array_utils.c +++ /dev/null @@ -1,32 +0,0 @@ -#include "array_utils.h" - -static inline void ska_array_utils_swap(int32* xp, int32* yp) { - int32 temp = *xp; - *xp = *yp; - *yp = temp; -} - -// Function to perform Selection Sort -void ska_array_utils_selection_sort_int(int32 arr[], int32 arraySize) { - int32 min_idx; - - // One by one move boundary of unsorted subarray - for (int32 i = 0; i < arraySize - 1; i++) { - - // Find the minimum element in unsorted array - min_idx = i; - for (int32 j = i + 1; j < arraySize; j++) { - if (arr[j] < arr[min_idx]) { - min_idx = j; - } - } - - // Swap the found minimum element - // with the first element - ska_array_utils_swap(&arr[min_idx], &arr[i]); - } -} - -void ska_array_utils_remove_item_uint32(uint32 array[], usize* size, uint32 item, uint32 emptyValue) { - SKA_ARRAY_UTILS_REMOVE_ARRAY_ITEM(array, *size, item, emptyValue); -} diff --git a/old_seika/data_structures/array_utils.h b/old_seika/data_structures/array_utils.h deleted file mode 100644 index 0473a8e..0000000 --- a/old_seika/data_structures/array_utils.h +++ /dev/null @@ -1,26 +0,0 @@ -#pragma once - -#include - -#include "seika/defines.h" - -#define SKA_ARRAY_UTILS_REMOVE_ARRAY_ITEM(ARRAY, ARRAY_SIZE, ELEMENT, EMPTY_VALUE) \ -{ \ -const usize temp_arac_size = (ARRAY_SIZE); \ -for (usize temp_arac_loop_index = 0; temp_arac_loop_index < temp_arac_size; temp_arac_loop_index++) { \ -if (ARRAY[temp_arac_loop_index] == ELEMENT) { \ -ARRAY[temp_arac_loop_index] = ARRAY[temp_arac_loop_index + 1]; \ -ARRAY[temp_arac_loop_index + 1] = EMPTY_VALUE; \ -(ARRAY_SIZE)--; \ -} \ -if (ARRAY[temp_arac_loop_index] == EMPTY_VALUE && temp_arac_loop_index + 1 < temp_arac_size) { \ -ARRAY[temp_arac_loop_index] = ARRAY[temp_arac_loop_index + 1]; \ -ARRAY[temp_arac_loop_index + 1] = EMPTY_VALUE; \ -} \ -} \ -} - -// Function to perform Selection Sort -void ska_array_utils_selection_sort_int(int32 arr[], int32 arraySize); - -void ska_array_utils_remove_item_uint32(uint32 array[], usize* size, uint32 item, uint32 emptyValue); diff --git a/old_seika/data_structures/hash_map.c b/old_seika/data_structures/hash_map.c deleted file mode 100644 index 3c77f5f..0000000 --- a/old_seika/data_structures/hash_map.c +++ /dev/null @@ -1,264 +0,0 @@ -#include "hash_map.h" - -#include - -#include "seika/memory.h" -#include "seika/assert.h" - -static usize se_default_hash(void* raw_key, usize key_size); -static int32 se_default_compare(void* first_key, void* second_key, usize key_size); - -static SkaHashMapNode* hash_map_create_node(SkaHashMap* hashMap, void* key, void* value, SkaHashMapNode* next); -static void hash_map_destroy_node(SkaHashMapNode* node); - -static bool hash_map_push_front(SkaHashMap* hashMap, usize index, void* key, void* value); -static void hash_map_grow_if_needed(SkaHashMap* hashMap); -static void hash_map_shrink_if_needed(SkaHashMap* hashMap); -static void hash_map_allocate(SkaHashMap* hashMap, usize capacity); -static void hash_map_resize(SkaHashMap* hashMap, usize capacity); - -SkaHashMap* ska_hash_map_create(usize keySize, usize valueSize, usize capacity) { - SkaHashMap* map = (SkaHashMap*) SKA_MEM_ALLOCATE_SIZE(sizeof(SkaHashMap)); - map->keySize = keySize; - map->valueSize = valueSize; - map->size = 0; - map->hashFunc = se_default_hash; - map->compareFunc = se_default_compare; - hash_map_allocate(map, capacity); - return map; -} - -SkaHashMapNode* hash_map_create_node(SkaHashMap* hashMap, void* key, void* value, SkaHashMapNode* next) { - SkaHashMapNode* node = (SkaHashMapNode*) SKA_MEM_ALLOCATE(SkaHashMapNode); - node->key = SKA_MEM_ALLOCATE_SIZE(hashMap->keySize); - node->value = SKA_MEM_ALLOCATE_SIZE(hashMap->valueSize); - memcpy(node->key, key, hashMap->keySize); - memcpy(node->value, value, hashMap->valueSize); - node->next = next; - return node; -} - -bool ska_hash_map_destroy(SkaHashMap* hashMap) { - SkaHashMapNode* node = NULL; - SkaHashMapNode* next = NULL; - for (usize chain = 0; chain < hashMap->capacity; chain++) { - node = hashMap->nodes[chain]; - while (node != NULL) { - next = node->next; - hash_map_destroy_node(node); - node = next; - } - } - - SKA_MEM_FREE(hashMap); - - return true; -} - -bool hash_map_push_front(SkaHashMap* hashMap, usize index, void* key, void* value) { - hashMap->nodes[index] = hash_map_create_node(hashMap, key, value, hashMap->nodes[index]); - return hashMap->nodes[index] != NULL; -} - -bool ska_hash_map_add(SkaHashMap* hashMap, void* key, void* value) { - SKA_ASSERT(hashMap != NULL); - SKA_ASSERT(key != NULL); - SKA_ASSERT(value != NULL); - - hash_map_grow_if_needed(hashMap); - - usize index = hashMap->hashFunc(key, hashMap->keySize) % hashMap->capacity; - if (ska_hash_map_has(hashMap, key)) { - SkaHashMapNode* node = hashMap->nodes[index]; - memcpy(node->value, value, hashMap->valueSize); - return true; // Updated Item - } - - if (!hash_map_push_front(hashMap, index, key, value)) { - return false; // Error - } - - hashMap->size++; - // Inserted - return true; -} - -bool ska_hash_map_has(SkaHashMap* hashMap, void* key) { - SKA_ASSERT(hashMap != NULL); - usize index = hashMap->hashFunc(key, hashMap->keySize) % hashMap->capacity; - for (SkaHashMapNode* node = hashMap->nodes[index]; node; node = node->next) { - if (hashMap->compareFunc(key, node->key, hashMap->keySize) == 0) { - return true; - } - } - return false; -} - -void* ska_hash_map_get(SkaHashMap* hashMap, void* key) { - SKA_ASSERT(hashMap != NULL); - usize index = hashMap->hashFunc(key, hashMap->keySize) % hashMap->capacity; - for (SkaHashMapNode* node = hashMap->nodes[index]; node; node = node->next) { - if (hashMap->compareFunc(key, node->key, hashMap->keySize) == 0) { - return node->value; - } - } - return NULL; -} - -bool ska_hash_map_erase(SkaHashMap* hashMap, void* key) { - SKA_ASSERT(hashMap != NULL); - SKA_ASSERT(key != NULL); - - usize index = hashMap->hashFunc(key, hashMap->keySize) % hashMap->capacity; - SkaHashMapNode* node = hashMap->nodes[index]; - for (SkaHashMapNode* previous = NULL; node; previous = node, node = node->next) { - if (hashMap->compareFunc(key, node->key, hashMap->keySize) == 0) { - if (previous != NULL) { - previous->next = node->next; - } else { - hashMap->nodes[index] = node->next; - } - - hash_map_destroy_node(node); - hashMap->size--; - - hash_map_shrink_if_needed(hashMap); - - return true; - } - } - - return false; -} - -void hash_map_grow_if_needed(SkaHashMap* hashMap) { - SKA_ASSERT_FMT(hashMap->size <= hashMap->capacity, "Hashmap size '%d' is bigger than its capacity '%d'!", hashMap->size, hashMap->capacity); - if (hashMap->size == hashMap->capacity) { - hash_map_resize(hashMap, hashMap->size * 2); - } -} - -void hash_map_shrink_if_needed(SkaHashMap* hashMap) { - SKA_ASSERT_FMT(hashMap->size <= hashMap->capacity, "Hashmap size '%d' is bigger than its capacity '%d'!", hashMap->size, hashMap->capacity); - usize shrinkCapacity = (usize) ((float) hashMap->capacity * SKA_HASH_MAP_SHRINK_THRESHOLD); - if (hashMap->size == shrinkCapacity) { - hash_map_resize(hashMap, shrinkCapacity); - } -} - -void hash_map_allocate(SkaHashMap* hashMap, usize capacity) { - hashMap->nodes = (SkaHashMapNode**)SKA_MEM_ALLOCATE_SIZE(capacity * sizeof(SkaHashMapNode*)); - memset(hashMap->nodes, 0, capacity * sizeof(SkaHashMapNode*)); - - hashMap->capacity = capacity; -} - -void hash_map_rehash(SkaHashMap* hashMap, SkaHashMapNode** oldNode, usize oldCapacity) { - for (usize chain = 0; chain < oldCapacity; chain++) { - for (SkaHashMapNode* node = oldNode[chain]; node != NULL;) { - SkaHashMapNode* next = node->next; - - usize newIndex = hashMap->hashFunc(node->key, hashMap->keySize) % hashMap->capacity; - node->next = hashMap->nodes[newIndex]; - hashMap->nodes[newIndex] = node; - - node = next; - } - } -} - -void hash_map_resize(SkaHashMap* hashMap, usize capacity) { - if (capacity < SKA_HASH_MAP_MIN_CAPACITY) { - if (hashMap->capacity > SKA_HASH_MAP_MIN_CAPACITY) { - capacity = SKA_HASH_MAP_MIN_CAPACITY; - } else { - // Do nothing since the passed in capacity is too low and the current map's capacity is already at min limit - return; - } - } - - SkaHashMapNode** oldNode = hashMap->nodes; - usize oldCapacity = hashMap->capacity; - hash_map_allocate(hashMap, capacity); - - hash_map_rehash(hashMap, oldNode, oldCapacity); - - SKA_MEM_FREE(oldNode); -} - -// --- Iterator --- // -SkaHashMapIterator ska_hash_map_iter_create(SkaHashMap* hashMap) { - // Get initial node if exists - SkaHashMapNode* initialNode = NULL; - usize initialIndex = 0; - for (usize chain = 0; chain < hashMap->capacity; chain++) { - SkaHashMapNode* node = hashMap->nodes[chain]; - if (node != NULL) { - initialNode = node; - initialIndex = chain + 1; - break; - } - } - usize iteratorCount = initialNode != NULL ? 1 : 0; - SkaHashMapIterator iterator = { .count = iteratorCount, .end = hashMap->capacity, .index = initialIndex, .pair = initialNode }; - return iterator; -} - -bool ska_hash_map_iter_is_valid(SkaHashMap* hashMap, SkaHashMapIterator* iterator) { - return iterator->pair != NULL && iterator->count <= hashMap->size; -} - -void ska_hash_map_iter_advance(SkaHashMap* hashMap, SkaHashMapIterator* iterator) { - if (ska_hash_map_iter_is_valid(hashMap, iterator)) { - if (iterator->pair->next != NULL) { - iterator->pair = iterator->pair->next; - iterator->count++; - return; - } - - // Search nodes array if there are no more linked pairs - for (usize chain = iterator->index; chain < hashMap->capacity; chain++) { - SkaHashMapNode* node = hashMap->nodes[chain]; - if (node != NULL) { - iterator->pair = node; - iterator->index = chain + 1; - iterator->count++; - return; - } - } - } - // Invalidate iterator since we've reached the end - iterator->pair = NULL; -} - -// Misc -usize se_default_hash(void* raw_key, usize key_size) { - // djb2 string hashing algorithm - // sstp://www.cse.yorku.ca/~oz/hash.ssml - usize byte; - usize hash = 5381; - char* key = (char*) raw_key; - - for (byte = 0; byte < key_size; ++byte) { - // (hash << 5) + hash = hash * 33 - hash = ((hash << 5) + hash) ^ key[byte]; - } - - return hash; -} - -int32 se_default_compare(void* first_key, void* second_key, usize key_size) { - return memcmp(first_key, second_key, key_size); -} - -void hash_map_destroy_node(SkaHashMapNode* node) { - SKA_ASSERT(node != NULL); - SKA_ASSERT(node->value != NULL); - SKA_ASSERT(node->key != NULL); - - SKA_MEM_FREE(node->key); - node->key = NULL; - SKA_MEM_FREE(node->value); - node->value = NULL; - SKA_MEM_FREE(node); -} diff --git a/old_seika/data_structures/hash_map.h b/old_seika/data_structures/hash_map.h deleted file mode 100644 index 852c99a..0000000 --- a/old_seika/data_structures/hash_map.h +++ /dev/null @@ -1,59 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -#include -#include - -#include "seika/defines.h" - -#define SKA_HASH_MAP_SHRINK_THRESHOLD 0.25f -#define SKA_HASH_MAP_MIN_CAPACITY 8 - -#define SKA_HASH_MAP_FOR_EACH(HASH_MAP, ITER_NAME) \ -for (SkaHashMapIterator ITER_NAME = ska_hash_map_iter_create(HASH_MAP); ska_hash_map_iter_is_valid(HASH_MAP, &(ITER_NAME)); ska_hash_map_iter_advance(HASH_MAP, &(ITER_NAME))) - -typedef usize (*SkaHashFunc) (void*, usize); -typedef int32 (*SkaCompareFunc) (void*, void*, usize); - -typedef struct SkaHashMapNode { - struct SkaHashMapNode* next; - void* key; - void* value; -} SkaHashMapNode; - -typedef struct SkaHashMap { - usize keySize; - usize valueSize; - usize capacity; - usize size; - SkaHashFunc hashFunc; - SkaCompareFunc compareFunc; - SkaHashMapNode** nodes; -} SkaHashMap; - -typedef struct SkaHashMapIterator { - usize count; - usize end; - usize index; - SkaHashMapNode* pair; -} SkaHashMapIterator; - -// Generic hash map methods -SkaHashMap* ska_hash_map_create(usize keySize, usize valueSize, usize capacity); -bool ska_hash_map_destroy(SkaHashMap* hashMap); -bool ska_hash_map_add(SkaHashMap* hashMap, void* key, void* value); -void* ska_hash_map_get(SkaHashMap* hashMap, void* key); -bool ska_hash_map_has(SkaHashMap* hashMap, void* key); -bool ska_hash_map_erase(SkaHashMap* hashMap, void* key); - -// Iterator -SkaHashMapIterator ska_hash_map_iter_create(SkaHashMap* hashMap); -bool ska_hash_map_iter_is_valid(SkaHashMap* hashMap, SkaHashMapIterator* iterator); -void ska_hash_map_iter_advance(SkaHashMap* hashMap, SkaHashMapIterator* iterator); - -#ifdef __cplusplus -} -#endif diff --git a/old_seika/data_structures/hash_map_string.c b/old_seika/data_structures/hash_map_string.c deleted file mode 100644 index f090614..0000000 --- a/old_seika/data_structures/hash_map_string.c +++ /dev/null @@ -1,295 +0,0 @@ -#include "hash_map_string.h" - -#include - -#include "seika/string.h" -#include "seika/memory.h" -#include "seika/assert.h" - -static usize ska_default_hash_string(const char* raw_key); -static int32 ska_default_compare_string(const char* first_key, const char* second_key); - -static SkaStringHashMapNode* hash_map_create_node_string(SkaStringHashMap* hashMap, const char* key, const void* value, usize valueSize, SkaStringHashMapNode* next); -static void hash_map_destroy_node_string(SkaStringHashMapNode* node); - -static bool hash_map_push_front_string(SkaStringHashMap* hashMap, usize index, const char* key, const void* value, usize valueSize); -static void string_hash_map_grow_if_needed(SkaStringHashMap* hashMap); -static void string_hash_map_shrink_if_needed(SkaStringHashMap* hashMap); -static void string_hash_map_allocate(SkaStringHashMap* hashMap, usize capacity); -static void string_hash_map_rehash(SkaStringHashMap* hashMap, SkaStringHashMapNode** oldNode, usize oldCapacity); -static void string_hash_map_resize(SkaStringHashMap* hashMap, usize newCapacity); - -SkaStringHashMap* ska_string_hash_map_create(usize capacity) { - SkaStringHashMap* map = (SkaStringHashMap*)SKA_MEM_ALLOCATE(SkaStringHashMap); - map->capacity = capacity; - map->size = 0; - map->hashFunc = ska_default_hash_string; - map->compareFunc = ska_default_compare_string; - map->nodes = (SkaStringHashMapNode**) SKA_MEM_ALLOCATE_SIZE(capacity * sizeof(SkaStringHashMapNode*)); - memset(map->nodes, 0, capacity * sizeof(SkaStringHashMapNode*)); // TODO: fix - return map; -} - -SkaStringHashMap* ska_string_hash_map_create_default_capacity() { - return ska_string_hash_map_create(SKA_STRING_HASH_MAP_MIN_CAPACITY); -} - -SkaStringHashMapNode* hash_map_create_node_string(SkaStringHashMap* hashMap, const char* key, const void* value, usize valueSize, SkaStringHashMapNode* next) { - SkaStringHashMapNode* node = (SkaStringHashMapNode*) SKA_MEM_ALLOCATE_SIZE(sizeof(SkaStringHashMapNode)); - node->key = ska_strdup(key); - node->value = SKA_MEM_ALLOCATE_SIZE(valueSize); - memcpy(node->value, value, valueSize); - node->valueSize = valueSize; - node->next = next; - return node; -} - -bool ska_string_hash_map_destroy(SkaStringHashMap* hashMap) { - SkaStringHashMapNode* node = NULL; - SkaStringHashMapNode* next = NULL; - for (usize chain = 0; chain < hashMap->capacity; chain++) { - node = hashMap->nodes[chain]; - while (node) { - next = node->next; - hash_map_destroy_node_string(node); - node = next; - } - } - - SKA_MEM_FREE(hashMap); - - return true; -} - -bool hash_map_push_front_string(SkaStringHashMap* hashMap, usize index, const char* key, const void* value, usize valueSize) { - hashMap->nodes[index] = hash_map_create_node_string(hashMap, key, value, valueSize, hashMap->nodes[index]); - return hashMap->nodes[index] != NULL; -} - -bool ska_string_hash_map_add(SkaStringHashMap* hashMap, const char* key, const void* value, usize valueSize) { - SKA_ASSERT(hashMap != NULL); - SKA_ASSERT(key != NULL); - SKA_ASSERT(value != NULL); - - string_hash_map_grow_if_needed(hashMap); - - usize index = hashMap->hashFunc(key) % hashMap->capacity; - if (ska_string_hash_map_has(hashMap, key)) { - SkaStringHashMapNode* node = hashMap->nodes[index]; - memcpy(node->value, value, valueSize); - return true; // Updated Item - } - - if (!hash_map_push_front_string(hashMap, index, key, value, valueSize)) { - return false; // Error - } - - hashMap->size++; - // Inserted - return true; -} - -bool ska_string_hash_map_has(SkaStringHashMap* hashMap, const char* key) { - SKA_ASSERT(hashMap != NULL); - usize index = hashMap->hashFunc(key) % hashMap->capacity; - for (SkaStringHashMapNode* node = hashMap->nodes[index]; node; node = node->next) { - if (hashMap->compareFunc(key, node->key) == 0) { - return true; - } - } - return false; -} - -void* ska_string_hash_map_get(SkaStringHashMap* hashMap, const char* key) { - SKA_ASSERT_FMT(hashMap != NULL, "Trying to get key '%s' from a NULL hashmap!", key); - usize index = hashMap->hashFunc(key) % hashMap->capacity; - for (SkaStringHashMapNode* node = hashMap->nodes[index]; node; node = node->next) { - if (hashMap->compareFunc(key, node->key) == 0) { - return node->value; - } - } - return NULL; -} - -// TODO: Make better... -void* ska_string_hash_map_find(SkaStringHashMap* hashMap, const char* key) { - if (ska_string_hash_map_has(hashMap, key)) { - return ska_string_hash_map_get(hashMap, key); - } - return NULL; -} - -bool ska_string_hash_map_erase(SkaStringHashMap* hashMap, const char* key) { - SKA_ASSERT(hashMap != NULL); - SKA_ASSERT(key != NULL); - - usize index = hashMap->hashFunc(key) % hashMap->capacity; - SkaStringHashMapNode* node = hashMap->nodes[index]; - for (SkaStringHashMapNode* previous = NULL; node; previous = node, node = node->next) { - if (hashMap->compareFunc(key, node->key) == 0) { - if (previous != NULL) { - previous->next = node->next; - } else { - hashMap->nodes[index] = node->next; - } - - hash_map_destroy_node_string(node); - hashMap->size--; - - string_hash_map_shrink_if_needed(hashMap); - - return true; - } - } - - return false; -} - -void string_hash_map_grow_if_needed(SkaStringHashMap* hashMap) { - SKA_ASSERT_FMT(hashMap->size <= hashMap->capacity, "Hashmap size '%d' is bigger than its capacity '%d'!", hashMap->size, hashMap->capacity); - if (hashMap->size == hashMap->capacity) { - string_hash_map_resize(hashMap, hashMap->size * 2); - } -} - -void string_hash_map_shrink_if_needed(SkaStringHashMap* hashMap) { - SKA_ASSERT_FMT(hashMap->size <= hashMap->capacity, "Hashmap size '%d' is bigger than its capacity '%d'!", hashMap->size, hashMap->capacity); - usize shrinkCapacity = (usize) ((float) hashMap->capacity * SKA_STRING_HASH_MAP_SHRINK_THRESHOLD); - if (hashMap->size == shrinkCapacity) { - string_hash_map_resize(hashMap, shrinkCapacity); - } -} - -void string_hash_map_allocate(SkaStringHashMap* hashMap, usize capacity) { - hashMap->nodes = SKA_MEM_ALLOCATE_SIZE(capacity * sizeof(SkaStringHashMapNode*)); - memset(hashMap->nodes, 0, capacity * sizeof(SkaStringHashMapNode*)); - - hashMap->capacity = capacity; -} - -void string_hash_map_rehash(SkaStringHashMap* hashMap, SkaStringHashMapNode** oldNode, usize oldCapacity) { - for (usize chain = 0; chain < oldCapacity; chain++) { - for (SkaStringHashMapNode* node = oldNode[chain]; node != NULL;) { - SkaStringHashMapNode* next = node->next; - - usize newIndex = hashMap->hashFunc(node->key) % hashMap->capacity; - node->next = hashMap->nodes[newIndex]; - hashMap->nodes[newIndex] = node; - - node = next; - } - } -} - -void string_hash_map_resize(SkaStringHashMap* hashMap, usize newCapacity) { - if (newCapacity < SKA_STRING_HASH_MAP_MIN_CAPACITY) { - if (hashMap->capacity > SKA_STRING_HASH_MAP_MIN_CAPACITY) { - newCapacity = SKA_STRING_HASH_MAP_MIN_CAPACITY; - } else { - // Do nothing since the passed in capacity is too low and the current map's capacity is already at min limit - return; - } - } - - SkaStringHashMapNode** oldNode = hashMap->nodes; - usize oldCapacity = hashMap->capacity; - string_hash_map_allocate(hashMap, newCapacity); - - string_hash_map_rehash(hashMap, oldNode, oldCapacity); - - SKA_MEM_FREE(oldNode); -} - -// Int -bool ska_string_hash_map_add_int(SkaStringHashMap* hashMap, const char* key, int32 value) { - return ska_string_hash_map_add(hashMap, key, &value, sizeof(int32)); -} - -int32 ska_string_hash_map_get_int(SkaStringHashMap* hashMap, const char* key) { - return *(int32*) ska_string_hash_map_get(hashMap, key); -} - -// String -bool ska_string_hash_map_add_string(SkaStringHashMap* hashMap, const char* key, const char* value) { - char* stringVal = ska_strdup(value); - bool result = ska_string_hash_map_add(hashMap, key, stringVal, strlen(value) + 1); - SKA_MEM_FREE(stringVal); - return result; -} - -char* ska_string_hash_map_get_string(SkaStringHashMap* hashMap, const char* key) { - return (char*) ska_string_hash_map_get(hashMap, key); -} - -//--- Iterator ---// -SkaStringHashMapIterator ska_string_hash_map_iter_create(SkaStringHashMap* hashMap) { - // Get initial node if exists - SkaStringHashMapNode* initialNode = NULL; - usize initialIndex = 0; - for (usize chain = 0; chain < hashMap->capacity; chain++) { - SkaStringHashMapNode* node = hashMap->nodes[chain]; - if (node != NULL) { - initialNode = node; - initialIndex = chain + 1; - break; - } - } - usize iteratorCount = initialNode != NULL ? 1 : 0; - SkaStringHashMapIterator iterator = { .count = iteratorCount, .end = hashMap->capacity, .index = initialIndex, .pair = initialNode }; - return iterator; -} - -bool ska_string_hash_map_iter_is_valid(SkaStringHashMap* hashMap, SkaStringHashMapIterator* iterator) { - return iterator->pair != NULL && iterator->count <= hashMap->size; -} - -void ska_string_hash_map_iter_advance(SkaStringHashMap* hashMap, SkaStringHashMapIterator* iterator) { - if (ska_string_hash_map_iter_is_valid(hashMap, iterator)) { - if (iterator->pair->next != NULL) { - iterator->pair = iterator->pair->next; - iterator->count++; - return; - } - - // Search nodes array if there are no more linked pairs - for (usize chain = iterator->index; chain < hashMap->capacity; chain++) { - SkaStringHashMapNode* node = hashMap->nodes[chain]; - if (node != NULL) { - iterator->pair = node; - iterator->index = chain + 1; - iterator->count++; - return; - } - } - } - // Invalidate iterator since we've reached the end - iterator->pair = NULL; -} - -// Misc -usize ska_default_hash_string(const char* raw_key) { - // djb2 string hashing algorithm - // sstp://www.cse.yorku.ca/~oz/hash.ssml - usize byte; - usize hash = 5381; - usize key_size = strlen(raw_key); - - for (byte = 0; byte < key_size; ++byte) { - hash = ((hash << 5) + hash) ^ raw_key[byte]; - } - - return hash; -} - -int32 ska_default_compare_string(const char* first_key, const char* second_key) { - return strcmp(first_key, second_key); -} - -void hash_map_destroy_node_string(SkaStringHashMapNode* node) { - SKA_ASSERT(node != NULL); - SKA_ASSERT(node->value != NULL); - SKA_ASSERT(node->key != NULL); - SKA_MEM_FREE(node->key); - SKA_MEM_FREE(node->value); - SKA_MEM_FREE(node); -} diff --git a/old_seika/data_structures/hash_map_string.h b/old_seika/data_structures/hash_map_string.h deleted file mode 100644 index 76207f3..0000000 --- a/old_seika/data_structures/hash_map_string.h +++ /dev/null @@ -1,66 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -#include -#include - -#include "seika/defines.h" - -#define SKA_STRING_HASH_MAP_SHRINK_THRESHOLD 0.25f -#define SKA_STRING_HASH_MAP_MIN_CAPACITY 8 - -#define SKA_STRING_HASH_MAP_FOR_EACH(HASH_MAP, ITER_NAME) \ -for (SkaStringHashMapIterator ITER_NAME = ska_string_hash_map_iter_create(HASH_MAP); ska_string_hash_map_iter_is_valid(HASH_MAP, &(ITER_NAME)); ska_string_hash_map_iter_advance(HASH_MAP, &(ITER_NAME))) - -typedef usize (*SkaStringHashFunc) (const char*); -typedef int32 (*SkaStringCompareFunc) (const char*, const char*); - -typedef struct SkaStringHashMapNode { - struct SkaStringHashMapNode* next; - char* key; - void* value; - usize valueSize; -} SkaStringHashMapNode; - -typedef struct SkaStringHashMap { - usize capacity; - usize size; - SkaStringHashFunc hashFunc; - SkaStringCompareFunc compareFunc; - SkaStringHashMapNode** nodes; -} SkaStringHashMap; - -typedef struct SkaStringHashMapIterator { - usize count; - usize end; - usize index; - SkaStringHashMapNode* pair; -} SkaStringHashMapIterator; - -// Generic hash map methods -SkaStringHashMap* ska_string_hash_map_create(usize capacity); -SkaStringHashMap* ska_string_hash_map_create_default_capacity(); -bool ska_string_hash_map_destroy(SkaStringHashMap* hashMap); -bool ska_string_hash_map_add(SkaStringHashMap* hashMap, const char* key, const void* value, usize valueSize); -void* ska_string_hash_map_get(SkaStringHashMap* hashMap, const char* key); -void* ska_string_hash_map_find(SkaStringHashMap* hashMap, const char* key); -bool ska_string_hash_map_has(SkaStringHashMap* hashMap, const char* key); -bool ska_string_hash_map_erase(SkaStringHashMap* hashMap, const char* key); -// Int -bool ska_string_hash_map_add_int(SkaStringHashMap* hashMap, const char* key, int value); -int ska_string_hash_map_get_int(SkaStringHashMap* hashMap, const char* key); -// String -bool ska_string_hash_map_add_string(SkaStringHashMap* hashMap, const char* key, const char* value); -char* ska_string_hash_map_get_string(SkaStringHashMap* hashMap, const char* key); - -// Iterator -SkaStringHashMapIterator ska_string_hash_map_iter_create(SkaStringHashMap* hashMap); -bool ska_string_hash_map_iter_is_valid(SkaStringHashMap* hashMap, SkaStringHashMapIterator* iterator); -void ska_string_hash_map_iter_advance(SkaStringHashMap* hashMap, SkaStringHashMapIterator* iterator); - -#ifdef __cplusplus -} -#endif diff --git a/old_seika/data_structures/linked_list.c b/old_seika/data_structures/linked_list.c deleted file mode 100644 index a774a09..0000000 --- a/old_seika/data_structures/linked_list.c +++ /dev/null @@ -1,265 +0,0 @@ -#include "linked_list.h" - -#include -#include - -#include "seika/memory.h" -#include "seika/assert.h" - -static inline void linked_list_delete_all_nodes(SkaLinkedList* list); -static inline SkaLinkedListNode* linked_list_create_node(SkaLinkedList* list, void* value, SkaLinkedListNode* next); -static inline void* linked_list_duplicate_node_value(SkaLinkedList* list, SkaLinkedListNode* node); - -// Public functions -SkaLinkedList* ska_linked_list_create(usize valueSize) { - SkaLinkedList* list = SKA_MEM_ALLOCATE(SkaLinkedList); - list->valueSize = valueSize; - return list; -} - -void ska_linked_list_destroy(SkaLinkedList* list) { - linked_list_delete_all_nodes(list); - SKA_MEM_FREE(list); -} - -void ska_linked_list_append(SkaLinkedList* list, void* value) { - SKA_ASSERT(list != NULL); - SKA_ASSERT(value != NULL); - SkaLinkedListNode* prevTail = list->tail; - list->tail = linked_list_create_node(list, value, NULL); - if (prevTail != NULL) { - prevTail->next = list->tail; - } - // If no head, set the head to tail. - if (list->head == NULL) { - list->head = list->tail; - } - list->size++; -} - -void ska_linked_list_prepend(SkaLinkedList* list, void* value) { - SKA_ASSERT(list != NULL); - SKA_ASSERT(value != NULL); - list->head = linked_list_create_node(list, value, list->head); - // If no tail, set the tail to head. - if (list->tail == NULL) { - list->tail = list->head; - } - list->size++; -} - -void ska_linked_list_insert(SkaLinkedList* list, void* value, usize index) { - SKA_ASSERT(list != NULL); - SKA_ASSERT(value != NULL); - // Check if at beginning or end of list, then just call those functions if so... - if (index > list->size) { - // Index is out of bounds, can return error if needed... - return; - } else if (index == 0) { - ska_linked_list_prepend(list, value); - return; - } else if (index == list->size) { - ska_linked_list_append(list, value); - return; - } - // Now we know it's at the middle of the list, iterate through nodes - usize nodeIndex = 1; - SkaLinkedListNode* prevNode = list->head; - SkaLinkedListNode* currentIndexNode = list->head->next; // Get the next value since the head exists and was checked - while (currentIndexNode != NULL) { - // We found the index node, now insert - if (index == nodeIndex) { - SkaLinkedListNode* currentIndexNodeNext = currentIndexNode->next; - prevNode->next = linked_list_create_node(list, value, currentIndexNodeNext); - list->size++; - return; - } - prevNode = currentIndexNode; - currentIndexNode = currentIndexNode->next; - nodeIndex++; - } - SKA_ASSERT_FMT(false, "Error with inserting into array list!"); -} - -void* ska_linked_list_get(SkaLinkedList* list, usize index) { - if (index < list->size) { - usize nodeIndex = 0; - SkaLinkedListNode* node = list->head; - while (node != NULL) { - if (index == nodeIndex) { - return node->value; - } - node = node->next; - nodeIndex++; - } - } - return NULL; -} - -void* ska_linked_list_get_front(SkaLinkedList* list) { - return list->head->value; -} - -void* ska_linked_list_get_back(SkaLinkedList* list) { - return list->tail->value; -} - -void* ska_linked_list_pop(SkaLinkedList* list, usize index) { - if (list->size > 0 && index < list->size) { - if (index == 0) { - return ska_linked_list_pop_front(list); - } else if (index == list->size - 1) { - return ska_linked_list_pop_back(list); - } - - // Search for node - usize nodeIndex = 1; - SkaLinkedListNode* nodeBeforePopped = list->head->next; - while (nodeBeforePopped != NULL) { - if (index - 1 == nodeIndex) { - break; - } - nodeBeforePopped = nodeBeforePopped->next; - nodeIndex++; - } - // Connect the previous node with the node that's being popped's next node - SKA_ASSERT(nodeBeforePopped->next); - SkaLinkedListNode* nodeToPop = nodeBeforePopped->next; - nodeBeforePopped->next = nodeToPop->next; - list->size--; - void* poppedValue = linked_list_duplicate_node_value(list, nodeToPop); - SKA_MEM_FREE(nodeToPop->value); - SKA_MEM_FREE(nodeToPop); - return poppedValue; - } - return NULL; -} - -void* ska_linked_list_pop_front(SkaLinkedList* list) { - if (list->size > 0) { - SkaLinkedListNode* nodeToPop = list->head; - list->head = nodeToPop->next; - list->size--; - if (list->size <= 1) { - list->tail = list->head; - } - void* poppedValue = linked_list_duplicate_node_value(list, nodeToPop); - SKA_MEM_FREE(nodeToPop->value); - SKA_MEM_FREE(nodeToPop); - return poppedValue; - } - return NULL; -} - -void* ska_linked_list_pop_back(SkaLinkedList* list) { - if (list->size == 1) { - return ska_linked_list_pop_front(list); - } else if (list->size == 2) { - SkaLinkedListNode* nodeToPop = list->tail; - list->tail = list->head; - list->size--; - void* poppedValue = linked_list_duplicate_node_value(list, nodeToPop); - SKA_MEM_FREE(nodeToPop); - return poppedValue; - } else if (list->size >= 3) { - SkaLinkedListNode* nodeToPop = list->head->next; - SkaLinkedListNode* nodePrev = list->head; - while (true) { - if (nodeToPop->next == NULL) { - break; - } - nodePrev = nodePrev->next; - nodeToPop = nodeToPop->next; - } - // Now that we have node to pop and previous node, pop it - nodePrev->next = nodeToPop->next; - list->size--; - void* poppedValue = linked_list_duplicate_node_value(list, nodeToPop); - SKA_MEM_FREE(nodeToPop->value); - SKA_MEM_FREE(nodeToPop); - return poppedValue; - } - return NULL; -} - -bool ska_linked_list_remove(SkaLinkedList* list, void* value) { - SkaLinkedListNode* currentNode = list->head; - SkaLinkedListNode* prevNode = NULL; - while (currentNode != NULL) { - if (memcmp(currentNode->value, value, list->valueSize) == 0) { - SkaLinkedListNode* nodeToDelete = currentNode; - // First entry - if (prevNode == NULL) { - list->head = currentNode->next; - if (list->size - 1 == 1) { - list->tail = list->head; - } - } else { - prevNode->next = currentNode->next; - // If at end, set tail - if (prevNode->next == NULL) { - list->tail = prevNode; - } - } - - list->size--; - SKA_MEM_FREE(nodeToDelete->value); - SKA_MEM_FREE(nodeToDelete); - return true; - } - prevNode = currentNode; - currentNode = currentNode->next; - } - return false; -} - -bool ska_linked_list_is_empty(SkaLinkedList* list) { - return list->size == 0; -} - -void ska_linked_list_sort(SkaLinkedList* list, SkaLinkedListIsGreaterThanFunc isGreaterThanFunc) { - if (list->head == NULL) { - return; - } - for (SkaLinkedListNode* current = list->head; current->next != NULL; current = current->next) { - for (SkaLinkedListNode* next = current->next; next != NULL; next = next->next) { - if (isGreaterThanFunc(current->value, next->value)) { - void* temp = current->value; - current->value = next->value; - next->value = temp; - } - } - } -} - -void ska_linked_list_clear(SkaLinkedList* list) { - linked_list_delete_all_nodes(list); -} - -// Private functions -static SkaLinkedListNode* linked_list_create_node(SkaLinkedList* list, void* value, SkaLinkedListNode* next) { - SkaLinkedListNode* node = SKA_MEM_ALLOCATE(SkaLinkedListNode); - node->value = SKA_MEM_ALLOCATE_SIZE(list->valueSize); - memcpy(node->value, value, list->valueSize); - node->next = next; - return node; -} - -static void* linked_list_duplicate_node_value(SkaLinkedList* list, SkaLinkedListNode* node) { - void* dupValue = SKA_MEM_ALLOCATE_SIZE(list->valueSize); - memcpy(dupValue, node->value, list->valueSize); - return dupValue; -} - -static void linked_list_delete_all_nodes(SkaLinkedList* list) { - SkaLinkedListNode* nodeToDelete = list->head; - while (nodeToDelete != NULL) { - SkaLinkedListNode* nextNode = nodeToDelete->next; - SKA_MEM_FREE(nodeToDelete->value); - SKA_MEM_FREE(nodeToDelete); - nodeToDelete = nextNode; - } - list->size = 0; - list->head = NULL; - list->tail = NULL; -} diff --git a/old_seika/data_structures/linked_list.h b/old_seika/data_structures/linked_list.h deleted file mode 100644 index cae8c6b..0000000 --- a/old_seika/data_structures/linked_list.h +++ /dev/null @@ -1,57 +0,0 @@ -#pragma once - -#include "seika/defines.h" - -#define SKA_LINKED_LIST_FOR_EACH(list, element) for((element) = (list)->head; (element) != NULL; (element) = (element)->next) - -// Should return whether the array list node is greater than the other -typedef bool (*SkaLinkedListIsGreaterThanFunc) (void*, void*); - -// Seika implementation of a single linked list -typedef struct SkaLinkedListNode { - struct SkaLinkedListNode* next; - void* value; -} SkaLinkedListNode; - -// Generic array list, use 'ska_linked_list_create' to allocate on the heap -typedef struct SkaLinkedList { - usize valueSize; - usize size; - SkaLinkedListNode* head; - SkaLinkedListNode* tail; -} SkaLinkedList; - -// Will create a new array list with all it's element values set to the passed in 'valueSize' -SkaLinkedList* ska_linked_list_create(usize valueSize); -// Will complete destroy the array list freeing up all its memory -void ska_linked_list_destroy(SkaLinkedList* list); - -// Adds an item at the end of the list -void ska_linked_list_append(SkaLinkedList* list, void* value); -// Adds an item at the beginning of the list -void ska_linked_list_prepend(SkaLinkedList* list, void* value); -// Inserts an item at the specified index -void ska_linked_list_insert(SkaLinkedList* list, void* value, usize index); - -// Returns an item from the list from specified index -void* ska_linked_list_get(SkaLinkedList* list, usize index); -// Same as 'ska_linked_list_get' but returns item from index 0 -void* ska_linked_list_get_front(SkaLinkedList* list); -// Same as 'ska_linked_list_get' but returns item from index (size - 1) -void* ska_linked_list_get_back(SkaLinkedList* list); - -// Removes and item and returns from the list from specified index, caller needs to manage memory -void* ska_linked_list_pop(SkaLinkedList* list, usize index); -// Same as 'ska_linked_list_pop' but removes and item from index 0, caller needs to manage memory -void* ska_linked_list_pop_front(SkaLinkedList* list); -// Same as 'ska_linked_list_pop' but removes and item from index (size - 1), caller needs to manage memory -void* ska_linked_list_pop_back(SkaLinkedList* list); -// Removes the first item from the list who is equal to the passed in value -bool ska_linked_list_remove(SkaLinkedList* list, void* value); - -// Returns true if the array list size == 0 -bool ska_linked_list_is_empty(SkaLinkedList* list); -// Will sort the array list, using the passed in 'isGreaterThanFunc' as a comparator for sorting -void ska_linked_list_sort(SkaLinkedList* list, SkaLinkedListIsGreaterThanFunc isGreaterThanFunc); -// Will remove all items from the array list -void ska_linked_list_clear(SkaLinkedList* list); diff --git a/old_seika/data_structures/queue.c b/old_seika/data_structures/queue.c deleted file mode 100644 index 9bd2599..0000000 --- a/old_seika/data_structures/queue.c +++ /dev/null @@ -1,60 +0,0 @@ -#include "queue.h" - -#include "seika/memory.h" - -SkaQueue* ska_queue_create(usize capacity, uint32 invalidValue) { - SkaQueue* queue = SKA_MEM_ALLOCATE(SkaQueue); - queue->capacity = capacity; - queue->invalidValue = invalidValue; - queue->size = 0; - queue->front = 0; - queue->rear = (uint32)capacity - 1; - queue->array = (uint32*)SKA_MEM_ALLOCATE_SIZE(queue->capacity * sizeof(uint32)); - return queue; -} - -void ska_queue_destroy(SkaQueue* queue) { - SKA_MEM_FREE(queue->array); - SKA_MEM_FREE(queue); -} - -bool ska_queue_is_full(SkaQueue* queue) { - return queue->size == queue->capacity; -} - -bool ska_queue_is_empty(SkaQueue* queue) { - return queue->size == 0; -} - -void ska_queue_enqueue(SkaQueue* queue, uint32 item) { - if (ska_queue_is_full(queue)) { - return; - } - queue->rear = (queue->rear + 1) % queue->capacity; - queue->array[queue->rear] = item; - queue->size++; -} - -uint32 ska_queue_dequeue(SkaQueue* queue) { - if (ska_queue_is_empty(queue)) { - return queue->invalidValue; - } - uint32 value = queue->array[queue->front]; - queue->front = (queue->front + 1) % queue->capacity; - queue->size--; - return value; -} - -uint32 ska_queue_front(SkaQueue* queue) { - if (ska_queue_is_empty(queue)) { - return queue->invalidValue; - } - return queue->array[queue->front]; -} - -uint32 ska_queue_rear(SkaQueue* queue) { - if (ska_queue_is_empty(queue)) { - return queue->invalidValue; - } - return queue->array[queue->rear]; -} diff --git a/old_seika/data_structures/queue.h b/old_seika/data_structures/queue.h deleted file mode 100644 index d388600..0000000 --- a/old_seika/data_structures/queue.h +++ /dev/null @@ -1,24 +0,0 @@ -#pragma once - -#include -#include - -#include "seika/defines.h" - -// TODO: If other types are needed, create a macro to simplify queues by type - -// Unsigned int queue -typedef struct SkaIdQueue { - uint32 front, rear, size, invalidValue; - usize capacity; - uint32* array; -} SkaIdQueue; - -SkaIdQueue* ska_queue_create(usize capacity, uint32 invalidValue); -void ska_queue_destroy(SkaIdQueue* queue); -bool ska_queue_is_full(SkaIdQueue* queue); -bool ska_queue_is_empty(SkaIdQueue* queue); -void ska_queue_enqueue(SkaIdQueue* queue, uint32 item); -uint32 ska_queue_dequeue(SkaIdQueue* queue); -uint32 ska_queue_front(SkaIdQueue* queue); -uint32 ska_queue_rear(SkaIdQueue* queue); diff --git a/old_seika/data_structures/spatial_hash_map.c b/old_seika/data_structures/spatial_hash_map.c deleted file mode 100644 index b66a822..0000000 --- a/old_seika/data_structures/spatial_hash_map.c +++ /dev/null @@ -1,264 +0,0 @@ -#include "spatial_hash_map.h" - -#include -#include - -#include "seika/memory.h" -#include "seika/assert.h" - -#define SKA_SPATIAL_HASH_NULL_ENTITY 4294967295 -#define SKA_SPATIAL_HASH_MAX_POSITION_HASH 8 - -typedef struct PositionHashes { - usize hashCount; - int32 hashes[SKA_SPATIAL_HASH_MAX_POSITION_HASH]; -} PositionHashes; - -static void spatial_hash_map_update(SkaSpatialHashMap* hashMap, uint32 entity, SkaSpatialHashMapGridSpacesHandle* handle, SkaRect2* collisionRect); -static bool change_cell_size_if_needed(SkaSpatialHashMap* hashMap, SkaRect2* collisionRectToCheck); -static int32 spatial_hash(SkaSpatialHashMap* hashMap, SkaVector2* position); -static SkaSpatialHashMapGridSpace* get_or_create_grid_space(SkaSpatialHashMap* hashMap, int32 positionHash); -static bool link_object_by_position_hash(SkaSpatialHashMap* hashMap, SkaSpatialHashMapGridSpacesHandle* object, uint32 value, int32 positionHash, PositionHashes* hashes); -static bool unlink_object_by_entity(SkaSpatialHashMap* hashMap, SkaSpatialHashMapGridSpacesHandle* object, SkaSpatialHashMapGridSpace* gridSpace, uint32 entity); -static void unlink_all_objects_by_entity(SkaSpatialHashMap* hashMap, SkaSpatialHashMapGridSpacesHandle* object, uint32 entity); -static bool collision_result_has_entity(SkaSpatialHashMapCollisionResult* result, uint32 entity); - -// Public facing functions -SkaSpatialHashMap* ska_spatial_hash_map_create(int32 initialCellSize) { - SkaSpatialHashMap* map = SKA_MEM_ALLOCATE(SkaSpatialHashMap); - map->cellSize = initialCellSize; - map->largestObjectSize = initialCellSize; - map->gridMap = ska_hash_map_create(sizeof(int32), sizeof(SkaSpatialHashMapGridSpace **), SKA_HASH_MAP_MIN_CAPACITY); - map->objectToGridMap = ska_hash_map_create(sizeof(uint32), sizeof(SkaSpatialHashMapGridSpacesHandle **), - SKA_HASH_MAP_MIN_CAPACITY); - map->doesCollisionDataNeedUpdating = false; - return map; -} - -void ska_spatial_hash_map_destroy(SkaSpatialHashMap* hashMap) { - // Grid map - SKA_HASH_MAP_FOR_EACH(hashMap->gridMap, iter) { - SkaHashMapNode* node = iter.pair; - SkaSpatialHashMapGridSpace* gridSpace = (SkaSpatialHashMapGridSpace*) *(SkaSpatialHashMapGridSpace**) node->value; - SKA_MEM_FREE(gridSpace); - } - ska_hash_map_destroy(hashMap->gridMap); - // Grid space Handle Map - SKA_HASH_MAP_FOR_EACH(hashMap->objectToGridMap, iter) { - SkaHashMapNode* node = iter.pair; - SkaSpatialHashMapGridSpacesHandle* handle = (SkaSpatialHashMapGridSpacesHandle*) *(SkaSpatialHashMapGridSpacesHandle**) node->value; - SKA_MEM_FREE(handle); - } - ska_hash_map_destroy(hashMap->objectToGridMap); - // Finally free the hashmap memory - SKA_MEM_FREE(hashMap); -} - -// The purpose of this function is to make sure that 'cellSize' is twice as big as the largest object -bool change_cell_size_if_needed(SkaSpatialHashMap* hashMap, SkaRect2* collisionRectToCheck) { - const int32 objectMaxSize = collisionRectToCheck->h > collisionRectToCheck->w ? (int32)collisionRectToCheck->h : (int32)collisionRectToCheck->w; - // Update largest object size of hashmap if applicable - if (objectMaxSize > hashMap->largestObjectSize) { - hashMap->largestObjectSize = objectMaxSize; - } - // Check if cell size needs to grow or shrink - if (objectMaxSize > hashMap->cellSize * 2 || hashMap->largestObjectSize < hashMap->cellSize / 8) { - hashMap->cellSize = objectMaxSize * 2; - return true; - } - - return false; -} - -SkaSpatialHashMapGridSpacesHandle* ska_spatial_hash_map_insert_or_update(SkaSpatialHashMap* hashMap, uint32 entity, SkaRect2* collisionRect) { - // Create new object handle if it doesn't exist - if (!ska_hash_map_has(hashMap->objectToGridMap, &entity)) { - SkaSpatialHashMapGridSpacesHandle* newHandle = SKA_MEM_ALLOCATE(SkaSpatialHashMapGridSpacesHandle); - newHandle->gridSpaceCount = 0; - newHandle->collisionRect = (SkaRect2) { - 0.0f, 0.0f, 0.0f, 0.0f - }; - ska_hash_map_add(hashMap->objectToGridMap, &entity, &newHandle); - } - - // Update cell size and rebuild map if an object is bigger than the cell size - if (change_cell_size_if_needed(hashMap, collisionRect)) { - // Since we have changed cell size and largest object size, rebuild spatial hash - SKA_HASH_MAP_FOR_EACH(hashMap->objectToGridMap, iter) { - const uint32 updatedEntity = *(uint32*) iter.pair->key; - if (entity != updatedEntity) { - SkaSpatialHashMapGridSpacesHandle* updatedHandle = (SkaSpatialHashMapGridSpacesHandle*) iter.pair->value; - spatial_hash_map_update(hashMap, updatedEntity, updatedHandle, &updatedHandle->collisionRect); - } - } - } - - SkaSpatialHashMapGridSpacesHandle* objectHandle = (SkaSpatialHashMapGridSpacesHandle*) *(SkaSpatialHashMapGridSpacesHandle**) ska_hash_map_get( - hashMap->objectToGridMap, &entity); - spatial_hash_map_update(hashMap, entity, objectHandle, collisionRect); - return objectHandle; -} - -void spatial_hash_map_update(SkaSpatialHashMap* hashMap, uint32 entity, SkaSpatialHashMapGridSpacesHandle* handle, SkaRect2* collisionRect) { - memcpy(&handle->collisionRect, collisionRect, sizeof(SkaRect2)); - - // Unlink all previous spaces and objects - unlink_all_objects_by_entity(hashMap, handle, entity); - - // Add values to spaces and spaces to object handles (moving clockwise starting from top-left) - PositionHashes hashes = { .hashCount = 0 }; - // Top left - const int32 topLeftHash = spatial_hash(hashMap, &(SkaVector2) { - collisionRect->x, collisionRect->y - }); - link_object_by_position_hash(hashMap, handle, entity, topLeftHash, &hashes); - // Top right - const int32 topRightHash = spatial_hash(hashMap, &(SkaVector2) { - collisionRect->x + collisionRect->w, collisionRect->y - }); - link_object_by_position_hash(hashMap, handle, entity, topRightHash, &hashes); - // Bottom Left - const int32 bottomLeftHash = spatial_hash(hashMap, &(SkaVector2) { - collisionRect->x, collisionRect->y + collisionRect->h - }); - link_object_by_position_hash(hashMap, handle, entity, bottomLeftHash, &hashes); - // Bottom Right - const int32 bottomRightHash = spatial_hash(hashMap, &(SkaVector2) { - collisionRect->x + collisionRect->w, collisionRect->y + collisionRect->h - }); - link_object_by_position_hash(hashMap, handle, entity, bottomRightHash, &hashes); -} - -void ska_spatial_hash_map_remove(SkaSpatialHashMap* hashMap, uint32 entity) { - if (!ska_hash_map_has(hashMap->objectToGridMap, &entity)) { - return; - } - SkaSpatialHashMapGridSpacesHandle* objectHandle = (SkaSpatialHashMapGridSpacesHandle*) *(SkaSpatialHashMapGridSpacesHandle**) ska_hash_map_get( - hashMap->objectToGridMap, &entity); - unlink_all_objects_by_entity(hashMap, objectHandle, entity); - ska_hash_map_erase(hashMap->objectToGridMap, &entity); - // TODO: Use something more efficient than looping through the entire hashmap to find the largest object size - const int32 MaxObjectSize = objectHandle->collisionRect.h > objectHandle->collisionRect.w ? (int32)objectHandle->collisionRect.h : (int32)objectHandle->collisionRect.w; - if (MaxObjectSize == hashMap->largestObjectSize) { - int32 foundLargestObjectSize = -1; - SKA_HASH_MAP_FOR_EACH(hashMap->objectToGridMap, iter) { - SkaSpatialHashMapGridSpacesHandle* nodeObjectHandle = (SkaSpatialHashMapGridSpacesHandle*) iter.pair->value; - const int32 nodeMaxObjectSize = nodeObjectHandle->collisionRect.h > nodeObjectHandle->collisionRect.w ? (int32)nodeObjectHandle->collisionRect.h : (int32)nodeObjectHandle->collisionRect.w; - // Early out if we find another object with the same size - if (nodeMaxObjectSize == hashMap->largestObjectSize) { - foundLargestObjectSize = -1; - break; - } else if(nodeMaxObjectSize > foundLargestObjectSize) { - foundLargestObjectSize = nodeMaxObjectSize; - } - } - if (foundLargestObjectSize > 0) { - hashMap->largestObjectSize = foundLargestObjectSize; - } - } - SKA_MEM_FREE(objectHandle); -} - -SkaSpatialHashMapGridSpacesHandle* ska_spatial_hash_map_get(SkaSpatialHashMap* hashMap, uint32 entity) { - if (ska_hash_map_has(hashMap->objectToGridMap, &entity)) { - return (SkaSpatialHashMapGridSpacesHandle*) *(SkaSpatialHashMapGridSpacesHandle**) ska_hash_map_get( - hashMap->objectToGridMap, &entity); - } - return NULL; -} - -SkaSpatialHashMapCollisionResult ska_spatial_hash_map_compute_collision(SkaSpatialHashMap* hashMap, uint32 entity) { - SkaSpatialHashMapCollisionResult result = { .collisionCount = 0 }; - void* objectHandlePtr = ska_hash_map_get(hashMap->objectToGridMap, &entity); - // Early out if object not in spatial hash map - if (objectHandlePtr == NULL) { - return result; - } - SkaSpatialHashMapGridSpacesHandle* objectHandle = (SkaSpatialHashMapGridSpacesHandle*) *(SkaSpatialHashMapGridSpacesHandle**) objectHandlePtr; - for (usize i = 0; i < objectHandle->gridSpaceCount; i++) { - SkaSpatialHashMapGridSpace* gridSpace = objectHandle->gridSpaces[i]; - for (usize j = 0; j < gridSpace->entityCount; j++) { - uint32 entityToCollide = gridSpace->entities[j]; - if (entity != entityToCollide && !collision_result_has_entity(&result, entityToCollide)) { - SkaSpatialHashMapGridSpacesHandle* entityToCollideObjectHandle = (SkaSpatialHashMapGridSpacesHandle*) *(SkaSpatialHashMapGridSpacesHandle**) ska_hash_map_get( - hashMap->objectToGridMap, &entityToCollide); - // Now that we have passed all checks, actually check collision - if (se_rect2_does_rectangles_overlap(&objectHandle->collisionRect, &entityToCollideObjectHandle->collisionRect)) { - SKA_ASSERT_FMT(result.collisionCount + 1 <= SKA_SPATIAL_HASH_GRID_MAX_COLLISIONS, "At limit of collisions '%d', consider increasing 'SE_SPATIAL_HASH_GRID_MAX_COLLISIONS'", SKA_SPATIAL_HASH_GRID_MAX_COLLISIONS); - result.collisions[result.collisionCount++] = entityToCollide; - } - } - } - } - return result; -} - -// Internal Functions -int32 spatial_hash(SkaSpatialHashMap* hashMap, SkaVector2* position) { - const int32 x = (int32) position->x / hashMap->cellSize; - const int32 y = (int32) position->y / hashMap->cellSize; - const int32 hash = ((x * x) ^ (y * y)) % INT32_MAX; - return hash; -} - -SkaSpatialHashMapGridSpace* get_or_create_grid_space(SkaSpatialHashMap* hashMap, int32 positionHash) { - if (!ska_hash_map_has(hashMap->gridMap, &positionHash)) { - SkaSpatialHashMapGridSpace* newGridSpace = SKA_MEM_ALLOCATE(SkaSpatialHashMapGridSpace); - newGridSpace->entityCount = 0; - ska_hash_map_add(hashMap->gridMap, &positionHash, &newGridSpace); - } - SkaSpatialHashMapGridSpace* gridSpace = (SkaSpatialHashMapGridSpace*) *(SkaSpatialHashMapGridSpace**) ska_hash_map_get( - hashMap->gridMap, &positionHash); - return gridSpace; -} - -bool link_object_by_position_hash(SkaSpatialHashMap* hashMap, SkaSpatialHashMapGridSpacesHandle* object, uint32 value, int32 positionHash, PositionHashes* hashes) { - // Exit if position hash exists - for (usize i = 0; i < hashes->hashCount; i++) { - if (positionHash == hashes->hashes[i]) { - return false; - } - } - // Link - SkaSpatialHashMapGridSpace* gridSpace = get_or_create_grid_space(hashMap, positionHash); - gridSpace->entities[gridSpace->entityCount++] = value; - object->gridSpaces[object->gridSpaceCount++] = gridSpace; - SKA_ASSERT_FMT(hashes->hashCount + 1 < SKA_SPATIAL_HASH_MAX_POSITION_HASH, - "Current hash count for value '%d' exceeds 'SE_SPATIAL_HASH_MAX_POSITION_HASH (%d)', consider increasing SE_SPATIAL_HASH_MAX_POSITION_HASH!"); - hashes->hashes[hashes->hashCount++] = positionHash; - return true; -} - -bool unlink_object_by_entity(SkaSpatialHashMap* hashMap, SkaSpatialHashMapGridSpacesHandle* object, SkaSpatialHashMapGridSpace* gridSpace, uint32 entity) { - bool objectUnlinked = false; - for (usize i = 0; i < gridSpace->entityCount; i++) { - if (entity == gridSpace->entities[i] || gridSpace->entities[i] == SKA_SPATIAL_HASH_NULL_ENTITY) { - if (i + 1 < gridSpace->entityCount) { - gridSpace->entities[i] = gridSpace->entities[i + 1]; - gridSpace->entities[i + 1] = SKA_SPATIAL_HASH_NULL_ENTITY; - } - objectUnlinked = true; - } - } - if (objectUnlinked) { - object->gridSpaceCount--; - gridSpace->entityCount--; - } - return objectUnlinked; -} - -void unlink_all_objects_by_entity(SkaSpatialHashMap* hashMap, SkaSpatialHashMapGridSpacesHandle* object, uint32 entity) { - const usize numberOfSpaces = object->gridSpaceCount; - for (usize i = 0; i < numberOfSpaces; i++) { - unlink_object_by_entity(hashMap, object, object->gridSpaces[i], entity); - } -} - -bool collision_result_has_entity(SkaSpatialHashMapCollisionResult* result, uint32 entity) { - for (usize i = 0; i < result->collisionCount; i++) { - if (entity == result->collisions[i]) { - return true; - } - } - return false; -} diff --git a/old_seika/data_structures/spatial_hash_map.h b/old_seika/data_structures/spatial_hash_map.h deleted file mode 100644 index e28a61e..0000000 --- a/old_seika/data_structures/spatial_hash_map.h +++ /dev/null @@ -1,43 +0,0 @@ -#pragma once - -#include "seika/math/math.h" -#include "hash_map.h" - -#define SKA_SPATIAL_HASH_GRID_SPACE_ENTITY_LIMIT 32 -#define SKA_SPATIAL_HASH_GRID_MAX_COLLISIONS 16 - -// Note: Spatial hash expects rectangles that have 0 rotation - -// Contains the object id for a particular grid space -typedef struct SkaSpatialHashMapGridSpace { - unsigned int entities[SKA_SPATIAL_HASH_GRID_SPACE_ENTITY_LIMIT]; - usize entityCount; -} SkaSpatialHashMapGridSpace; - -// Contains all grid spaces an object is assigned to -typedef struct SkaSpatialHashMapGridSpacesHandle { - usize gridSpaceCount; - SkaRect2 collisionRect; - SkaSpatialHashMapGridSpace* gridSpaces[4]; -} SkaSpatialHashMapGridSpacesHandle; - -// Contains a hash map of buckets that correspond to a space on a grid -typedef struct SkaSpatialHashMap { - int cellSize; // Cell size should be 2x the size of the largest object - int largestObjectSize; // Used to keep track of the largest object size. If size is 8x less than cell size, we should resize spatial hash. - SkaHashMap* gridMap; // Contains objects within a grid. - SkaHashMap* objectToGridMap; // Contains contains all grid spaces an object is assigned to. - bool doesCollisionDataNeedUpdating; -} SkaSpatialHashMap; - -typedef struct SkaSpatialHashMapCollisionResult { - usize collisionCount; - unsigned int collisions[SKA_SPATIAL_HASH_GRID_MAX_COLLISIONS]; -} SkaSpatialHashMapCollisionResult; - -SkaSpatialHashMap* ska_spatial_hash_map_create(int32 initialCellSize); -void ska_spatial_hash_map_destroy(SkaSpatialHashMap* hashMap); -SkaSpatialHashMapGridSpacesHandle* ska_spatial_hash_map_insert_or_update(SkaSpatialHashMap* hashMap, uint32 entity, SkaRect2* collisionRect); -void ska_spatial_hash_map_remove(SkaSpatialHashMap* hashMap, uint32 entity); -SkaSpatialHashMapGridSpacesHandle* ska_spatial_hash_map_get(SkaSpatialHashMap* hashMap, uint32 entity); -SkaSpatialHashMapCollisionResult ska_spatial_hash_map_compute_collision(SkaSpatialHashMap* hashMap, uint32 entity); diff --git a/old_seika/data_structures/static_array.h b/old_seika/data_structures/static_array.h deleted file mode 100644 index 0302ca2..0000000 --- a/old_seika/data_structures/static_array.h +++ /dev/null @@ -1,108 +0,0 @@ -#pragma once - -#include - -#include "array_utils.h" - -// Helper class for generalized use of static arrays - -#define SKA_STATIC_ARRAY_CREATE(ARRAY_TYPE, ARRAY_SIZE, ARRAY_NAME) \ -static ARRAY_TYPE ARRAY_NAME[ARRAY_SIZE]; \ -static usize ARRAY_NAME ##_count = 0 - -#define SKA_STATIC_ARRAY_FOR_LOOP(ARRAY_NAME) \ -for (usize ARRAY_NAME ##_loop_index = 0; ARRAY_NAME ##_loop_index < ARRAY_NAME ##_count; ARRAY_NAME ##_loop_index++) - -#define SKA_STATIC_ARRAY_ADD(ARRAY_NAME, ARRAY_VALUE) \ -ARRAY_NAME[ARRAY_NAME ##_count++] = ARRAY_VALUE - -#define SKA_STATIC_ARRAY_ADD_IF_UNIQUE(ARRAY_NAME, ARRAY_VALUE) \ -{ \ -bool ARRAY_NAME ##_has_duplicate = false; \ -for (usize ARRAY_NAME ##_loop_index = 0; ARRAY_NAME ##_loop_index < ARRAY_NAME ##_count; ARRAY_NAME ##_loop_index++) { \ -if (ARRAY_NAME[ARRAY_NAME ##_loop_index] == ARRAY_VALUE) { \ -ARRAY_NAME ##_has_duplicate = true; \ -break; \ -}\ -} \ -if (!ARRAY_NAME ##_has_duplicate) { \ -SKA_STATIC_ARRAY_ADD(ARRAY_NAME, ARRAY_VALUE); \ -} \ -} - -#define SKA_STATIC_ARRAY_REMOVE(ARRAY_NAME, ARRAY_VALUE, EMPTY_VALUE) \ -{ \ -const usize ARRAY_NAME ##_count_ref = ARRAY_NAME ##_count; \ -for (usize ARRAY_NAME ##_loop_index = 0; ARRAY_NAME ##_loop_index < ARRAY_NAME ##_count_ref; ARRAY_NAME ##_loop_index++) { \ -if (ARRAY_NAME[ARRAY_NAME ##_loop_index] == ARRAY_VALUE) { \ -ARRAY_NAME[ARRAY_NAME ##_loop_index] = ARRAY_NAME[ARRAY_NAME ##_loop_index + 1]; \ -ARRAY_NAME[ARRAY_NAME ##_loop_index + 1] = EMPTY_VALUE; \ -ARRAY_NAME ##_count--; \ -} \ -if (ARRAY_NAME[ARRAY_NAME ##_loop_index] == EMPTY_VALUE && ARRAY_NAME ##_loop_index + 1 < ARRAY_NAME ##_count_ref) { \ -ARRAY_NAME[ARRAY_NAME ##_loop_index] = ARRAY_NAME[ARRAY_NAME ##_loop_index + 1]; \ -ARRAY_NAME[ARRAY_NAME ##_loop_index + 1] = EMPTY_VALUE; \ -} \ -} \ -} - -#define SKA_STATIC_ARRAY_REMOVE_WITH_PREDICATE(ARRAY_NAME, ARRAY_VALUE, EMPTY_VALUE, ARRAY_TYPE, PRED_FUNC) \ -{ \ -bool (*static_array_compare_func)(ARRAY_TYPE first, ARRAY_TYPE second) = PRED_FUNC; \ -const usize ARRAY_NAME ##_count_ref = ARRAY_NAME ##_count; \ -for (usize ARRAY_NAME ##_loop_index = 0; ARRAY_NAME ##_loop_index < ARRAY_NAME ##_count_ref; ARRAY_NAME ##_loop_index++) { \ -if (static_array_compare_func(ARRAY_NAME[ARRAY_NAME ##_loop_index], ARRAY_VALUE)) { \ -ARRAY_NAME[ARRAY_NAME ##_loop_index] = ARRAY_NAME[ARRAY_NAME ##_loop_index + 1]; \ -ARRAY_NAME[ARRAY_NAME ##_loop_index + 1] = EMPTY_VALUE; \ -ARRAY_NAME ##_count--; \ -} \ -if (ARRAY_NAME[ARRAY_NAME ##_loop_index] == EMPTY_VALUE && ARRAY_NAME ##_loop_index + 1 < ARRAY_NAME ##_count_ref) { \ -ARRAY_NAME[ARRAY_NAME ##_loop_index] = ARRAY_NAME[ARRAY_NAME ##_loop_index + 1]; \ -ARRAY_NAME[ARRAY_NAME ##_loop_index + 1] = EMPTY_VALUE; \ -} \ -} \ -} - -#define SKA_STATIC_ARRAY_EMPTY(ARRAY_NAME) \ -ARRAY_NAME ##_count = 0; - -#define SKA_STATIC_ARRAY_SIZE(ARRAY_NAME) (ARRAY_NAME ##_count) - -#define SKA_STATIC_ARRAY_SORT_INT(ARRAY_NAME) \ -if (SKA_STATIC_ARRAY_SIZE(ARRAY_NAME) > 0) { \ -ska_array_utils_selection_sort_int(ARRAY_NAME, (int32)SKA_STATIC_ARRAY_SIZE(ARRAY_NAME)); \ -} - -// Array Utils (TODO: Move in own file) -#define SKA_ARRAY_REMOVE_AND_CONDENSE(ARRAY_NAME, ARRAY_SIZE_VAR, ARRAY_VALUE, EMPTY_VALUE) \ -{ \ -const usize temp_arac_size = ARRAY_SIZE_VAR; \ -for (usize temp_arac_loop_index = 0; temp_arac_loop_index < temp_arac_size; temp_arac_loop_index++) { \ -if (ARRAY_NAME[temp_arac_loop_index] == ARRAY_VALUE) { \ -ARRAY_NAME[temp_arac_loop_index] = ARRAY_NAME[temp_arac_loop_index + 1]; \ -ARRAY_NAME[temp_arac_loop_index + 1] = EMPTY_VALUE; \ -ARRAY_SIZE_VAR--; \ -} \ -if (ARRAY_NAME[temp_arac_loop_index] == EMPTY_VALUE && temp_arac_loop_index + 1 < temp_arac_size) { \ -ARRAY_NAME[temp_arac_loop_index] = ARRAY_NAME[temp_arac_loop_index + 1]; \ -ARRAY_NAME[temp_arac_loop_index + 1] = EMPTY_VALUE; \ -} \ -} \ -} - -#define SKA_ARRAY_REMOVE_AND_CONDENSE_PREDICATE(ARRAY_NAME, ARRAY_SIZE_VAR, ARRAY_VALUE, EMPTY_VALUE, ARRAY_TYPE, PRED_FUNC) \ -{ \ -bool (*static_array_compare_func)(ARRAY_TYPE first, ARRAY_TYPE second) = PRED_FUNC; \ -const usize temp_arac_size = ARRAY_SIZE_VAR; \ -for (usize temp_arac_loop_index = 0; temp_arac_loop_index < temp_arac_size; temp_arac_loop_index++) { \ -if (static_array_compare_func(ARRAY_NAME[temp_arac_loop_index], ARRAY_VALUE)) { \ -ARRAY_NAME[temp_arac_loop_index] = ARRAY_NAME[temp_arac_loop_index + 1]; \ -ARRAY_NAME[temp_arac_loop_index + 1] = EMPTY_VALUE; \ -ARRAY_SIZE_VAR--; \ -} \ -if (ARRAY_NAME[temp_arac_loop_index] == EMPTY_VALUE && temp_arac_loop_index + 1 < temp_arac_size) { \ -ARRAY_NAME[temp_arac_loop_index] = ARRAY_NAME[temp_arac_loop_index + 1]; \ -ARRAY_NAME[temp_arac_loop_index + 1] = EMPTY_VALUE; \ -} \ -} \ -} diff --git a/old_seika/data_structures/tile_map.h b/old_seika/data_structures/tile_map.h deleted file mode 100644 index 7e7e10a..0000000 --- a/old_seika/data_structures/tile_map.h +++ /dev/null @@ -1,22 +0,0 @@ -#pragma once - -#include "seika/math/math.h" -#include "seika/rendering/texture.h" - -#define SKA_TILE_MAP_MAX_TILES 36 - -typedef struct SkaTile { - SkaVector2 position; -} SkaTile; - -typedef struct SkaTileMap { - SkaTexture* tileSpriteSheet; - SkaVector2 tileSize; - SkaTile tiles[36]; -} SkaTileMap; - -SkaTileMap* ska_tile_map_create(SkaTexture* tileSpriteSheet); -void ska_tile_map_add_tile(SkaTileMap* tileMap, SkaVector2 position); -SkaTile* ska_tile_map_get_tile(SkaTileMap* tileMap, SkaVector2 position); -SkaTile* ska_tile_map_has_tile(SkaTileMap* tileMap, SkaVector2 position); -void ska_tile_map_destroy(SkaTileMap* tileMap); diff --git a/old_seika/defines.h b/old_seika/defines.h deleted file mode 100644 index 1c4c9e7..0000000 --- a/old_seika/defines.h +++ /dev/null @@ -1,43 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -#include -#include -#include - -#include "version_info.h" - -typedef size_t usize; - -typedef int16_t int16; -typedef int32_t int32; -typedef int64_t int64; - -typedef uint32_t uint32; -typedef uint64_t uint64; - -typedef float f32; -typedef double f64; - -#ifndef DEBUG -#define SKA_IF_DEBUG(STATEMENT) \ -do { STATEMENT } while(false) -#else -#define SE_DEBUG_MACRO(CONDITION, STATEMENT) \ -do {} while (false) -#endif - -// Used to define literal structs that are compatible from both c and c++ -#ifndef __cplusplus -#define SKA_STRUCT_LITERAL(STRUCT_NAME) \ -(STRUCT_NAME) -#else -#define SKA_STRUCT_LITERAL(STRUCT_NAME) -#endif - -#ifdef __cplusplus -} -#endif diff --git a/old_seika/ecs/component.c b/old_seika/ecs/component.c deleted file mode 100644 index 0aee34a..0000000 --- a/old_seika/ecs/component.c +++ /dev/null @@ -1,191 +0,0 @@ -#include "component.h" - -#include - -#include "seika/string.h" -#include "seika/memory.h" -#include "seika/assert.h" -#include "seika/data_structures/hash_map_string.h" - -//--- Component ---// -static SkaComponentIndex globalComponentIndex = 0; -static SkaStringHashMap* componentNameToTypeMap = NULL; - -const SkaComponentTypeInfo* ska_ecs_component_register_type(const char* name, usize componentSize) { - SKA_ASSERT_FMT(globalComponentIndex + 1 < SKA_ECS_MAX_COMPONENTS, "Over the maximum allowed components which are '%d'", SKA_ECS_MAX_COMPONENTS); - // Check if component already exists and return that index if it does - const SkaComponentTypeInfo* typeInfo = (SkaComponentTypeInfo*)ska_string_hash_map_find(componentNameToTypeMap, name); - if (typeInfo) { - return typeInfo; - } - // Add new type info for component - const SkaComponentIndex newTypeIndex = globalComponentIndex++; - const SkaComponentTypeInfo newTypeInfo = { - .name = ska_strdup(name), - .type = 1 << newTypeIndex, // Bitshift for flag assignment - .index = newTypeIndex, - .size = componentSize - }; - ska_string_hash_map_add(componentNameToTypeMap, name, &newTypeInfo, sizeof(SkaComponentTypeInfo)); - return ska_ecs_component_get_type_info(name, componentSize); -} - -const SkaComponentTypeInfo* ska_ecs_component_get_type_info(const char* name, usize componentSize) { - const SkaComponentTypeInfo* typeInfo = (SkaComponentTypeInfo*)ska_string_hash_map_find(componentNameToTypeMap, name); - SKA_ASSERT(typeInfo); - SKA_ASSERT(typeInfo->size == componentSize); - return typeInfo; -} - -const SkaComponentTypeInfo* ska_ecs_component_find_type_info(const char* name) { - const SkaComponentTypeInfo* typeInfo = (SkaComponentTypeInfo*)ska_string_hash_map_find(componentNameToTypeMap, name); - return typeInfo; -} - -SkaComponentType ska_ecs_component_get_type_flag(const char* name, usize componentSize) { - const SkaComponentTypeInfo* typeInfo = ska_ecs_component_get_type_info(name, componentSize); - return typeInfo->type; -} - -//--- Component Array ---// -typedef struct ComponentArray { - void* components[SKA_ECS_MAX_COMPONENTS]; -} ComponentArray; - -static ComponentArray* component_array_create() { - ComponentArray* componentArray = SKA_MEM_ALLOCATE(ComponentArray); - for (unsigned int i = 0; i < SKA_ECS_MAX_COMPONENTS; i++) { - componentArray->components[i] = NULL; - } - return componentArray; -} - -static void component_array_initialize(ComponentArray* componentArray) { - for (unsigned int i = 0; i < SKA_ECS_MAX_COMPONENTS; i++) { - componentArray->components[i] = NULL; - } -} - -static bool component_array_has_component(ComponentArray* componentArray, SkaComponentIndex index) { - return componentArray->components[index] == NULL ? false : true; -} - -static void* component_array_get_component(ComponentArray* componentArray, SkaComponentIndex index) { - return componentArray->components[index]; -} - -static void component_array_set_component(ComponentArray* componentArray, SkaComponentIndex index, void* component) { - componentArray->components[index] = component; -} - -static void component_array_remove_component(ComponentArray* componentArray, SkaComponentIndex index) { - SKA_MEM_FREE(componentArray->components[index]); - componentArray->components[index] = NULL; -} - -static void component_array_remove_all_components(ComponentArray* componentArray) { - for (usize i = 0; i < SKA_ECS_MAX_COMPONENTS; i++) { - component_array_remove_component(componentArray, (SkaComponentIndex)i); - } -} - -//--- Component Manager ---// -typedef struct ComponentManager { - ComponentArray entityComponentArrays[SKA_MAX_ENTITIES]; - SkaComponentType entityComponentSignatures[SKA_MAX_ENTITIES]; -} ComponentManager; - -static ComponentManager* componentManager = NULL; - -static SkaComponentType component_manager_translate_index_to_type(SkaComponentIndex index); - -void ska_ecs_component_manager_initialize() { - SKA_ASSERT(componentNameToTypeMap == NULL); - componentNameToTypeMap = ska_string_hash_map_create_default_capacity(); - - SKA_ASSERT_FMT(componentManager == NULL, "Component Manager is not NULL when trying to initialize"); - componentManager = SKA_MEM_ALLOCATE(ComponentManager); -} - -// Assumes component data was already deleted previously -void ska_ecs_component_manager_finalize() { - SKA_ASSERT(componentNameToTypeMap != NULL); - SKA_STRING_HASH_MAP_FOR_EACH(componentNameToTypeMap, iter) { - SkaStringHashMapNode* node = iter.pair; - SkaComponentTypeInfo* typeInfo = (SkaComponentTypeInfo*)node->value; - if (typeInfo) { - SKA_MEM_FREE(typeInfo->name); - } - } - ska_string_hash_map_destroy(componentNameToTypeMap); - componentNameToTypeMap = NULL; - globalComponentIndex = 0; - - SKA_ASSERT_FMT(componentManager != NULL, "Component Manager is NULL when trying to finalize..."); - SKA_MEM_FREE(componentManager); - componentManager = NULL; -} - -void* ska_ecs_component_manager_get_component(SkaEntity entity, SkaComponentIndex index) { - void* component = component_array_get_component(&componentManager->entityComponentArrays[entity], index); - SKA_ASSERT_FMT(component != NULL, "Entity '%d' doesn't have '%s' component!", entity, ska_ecs_component_get_component_data_index_string(index)); - return component; -} - -void* ska_ecs_component_manager_get_component_unchecked(SkaEntity entity, SkaComponentIndex index) { - return component_array_get_component(&componentManager->entityComponentArrays[entity], index); -} - -void ska_ecs_component_manager_set_component(SkaEntity entity, SkaComponentIndex index, void* component) { - component_array_set_component(&componentManager->entityComponentArrays[entity], index, component); - // Update signature - SkaComponentType componentSignature = ska_ecs_component_manager_get_component_signature(entity); - componentSignature |= component_manager_translate_index_to_type(index); - ska_ecs_component_manager_set_component_signature(entity, componentSignature); -} - -void ska_ecs_component_manager_remove_component(SkaEntity entity, SkaComponentIndex index) { - SkaComponentType componentSignature = ska_ecs_component_manager_get_component_signature(entity); - componentSignature &= component_manager_translate_index_to_type(index); - ska_ecs_component_manager_set_component_signature(entity, componentSignature); - component_array_remove_component(&componentManager->entityComponentArrays[entity], index); -} - -void ska_ecs_component_manager_remove_all_components(SkaEntity entity) { - component_array_remove_all_components(&componentManager->entityComponentArrays[entity]); - ska_ecs_component_manager_set_component_signature(entity, SKA_ECS_COMPONENT_TYPE_NONE); -} - -bool ska_ecs_component_manager_has_component(SkaEntity entity, SkaComponentIndex index) { - return component_array_has_component(&componentManager->entityComponentArrays[entity], index); -} - -void ska_ecs_component_manager_set_component_signature(SkaEntity entity, SkaComponentType componentTypeSignature) { - componentManager->entityComponentSignatures[entity] = componentTypeSignature; -} - -SkaComponentType ska_ecs_component_manager_get_component_signature(SkaEntity entity) { - return componentManager->entityComponentSignatures[entity]; -} - -SkaComponentType component_manager_translate_index_to_type(SkaComponentIndex index) { - SKA_STRING_HASH_MAP_FOR_EACH(componentNameToTypeMap, iter) { - SkaStringHashMapNode* node = iter.pair; - const SkaComponentTypeInfo* typeInfo = (SkaComponentTypeInfo*)node->value; - if (typeInfo->index == index) { - return typeInfo->type; - } - } - return SKA_ECS_COMPONENT_TYPE_NONE; -} - -const char* ska_ecs_component_get_component_data_index_string(SkaComponentIndex index) { - SKA_STRING_HASH_MAP_FOR_EACH(componentNameToTypeMap, iter) { - SkaStringHashMapNode* node = iter.pair; - const SkaComponentTypeInfo* typeInfo = (SkaComponentTypeInfo*)node->value; - if (typeInfo->index == index) { - return typeInfo->name; - } - } - return "INVALID"; -} diff --git a/old_seika/ecs/component.h b/old_seika/ecs/component.h deleted file mode 100644 index 881695a..0000000 --- a/old_seika/ecs/component.h +++ /dev/null @@ -1,57 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -#include -#include - -#include "entity.h" - -#define SKA_ECS_MAX_COMPONENTS 32 -#define SKA_ECS_COMPONENT_TYPE_NONE ((SkaComponentType)0) - -#define SKA_ECS_REGISTER_COMPONENT(ComponentType) \ -ska_ecs_component_register_type(#ComponentType, sizeof(ComponentType)) - -#define SKA_ECS_COMPONENT_TYPE_INFO(ComponentType) \ -ska_ecs_component_get_type_info(#ComponentType, sizeof(ComponentType)) - -#define SKA_ECS_COMPONENT_TYPE_FLAG(ComponentType) \ -ska_ecs_component_get_type_flag(#ComponentType, sizeof(ComponentType)) - -typedef uint32 SkaComponentIndex; -typedef uint32 SkaComponentType; - -typedef struct SkaComponentTypeInfo { - char* name; - SkaComponentType type; - SkaComponentIndex index; - usize size; -} SkaComponentTypeInfo; - - - -const SkaComponentTypeInfo* ska_ecs_component_register_type(const char* name, usize componentSize); -const SkaComponentTypeInfo* ska_ecs_component_get_type_info(const char* name, usize componentSize); -const SkaComponentTypeInfo* ska_ecs_component_find_type_info(const char* name); -SkaComponentType ska_ecs_component_get_type_flag(const char* name, usize componentSize); - -// --- Component Manager --- // -void ska_ecs_component_manager_initialize(); -void ska_ecs_component_manager_finalize(); -void* ska_ecs_component_manager_get_component(SkaEntity entity, SkaComponentIndex index); -void* ska_ecs_component_manager_get_component_unchecked(SkaEntity entity, SkaComponentIndex index); // No check, will probably consolidate later... -void ska_ecs_component_manager_set_component(SkaEntity entity, SkaComponentIndex index, void* component); -void ska_ecs_component_manager_remove_component(SkaEntity entity, SkaComponentIndex index); -void ska_ecs_component_manager_remove_all_components(SkaEntity entity); -bool ska_ecs_component_manager_has_component(SkaEntity entity, SkaComponentIndex index); -void ska_ecs_component_manager_set_component_signature(SkaEntity entity, SkaComponentType componentTypeSignature); -SkaComponentType ska_ecs_component_manager_get_component_signature(SkaEntity entity); - -const char* ska_ecs_component_get_component_data_index_string(SkaComponentIndex index); - -#ifdef __cplusplus -} -#endif diff --git a/old_seika/ecs/ec_system.c b/old_seika/ecs/ec_system.c deleted file mode 100644 index f5afd9b..0000000 --- a/old_seika/ecs/ec_system.c +++ /dev/null @@ -1,331 +0,0 @@ -#include "ec_system.h" - -#include - -#include "seika/string.h" -#include "seika/flag_utils.h" -#include "seika/logger.h" -#include "seika/memory.h" -#include "seika/assert.h" - -//--- EC System Manager ---// -#define MAX_ENTITY_SYSTEMS_PER_HOOK 12 - -typedef struct EntitySystemData { - usize entity_systems_count; - usize on_entity_start_systems_count; - usize on_entity_end_systems_count; - usize on_entity_entered_scene_systems_count; - usize render_systems_count; - usize pre_update_all_systems_count; - usize post_update_all_systems_count; - usize update_systems_count; - usize fixed_update_systems_count; - usize network_callback_systems_count; - SkaECSSystem* entity_systems[SKA_ECS_MAX_COMPONENTS]; - SkaECSSystem* on_entity_start_systems[MAX_ENTITY_SYSTEMS_PER_HOOK]; - SkaECSSystem* on_entity_end_systems[MAX_ENTITY_SYSTEMS_PER_HOOK]; - SkaECSSystem* on_entity_entered_scene_systems[MAX_ENTITY_SYSTEMS_PER_HOOK]; - SkaECSSystem* render_systems[MAX_ENTITY_SYSTEMS_PER_HOOK]; - SkaECSSystem* update_systems[MAX_ENTITY_SYSTEMS_PER_HOOK]; - SkaECSSystem* pre_update_all_systems[MAX_ENTITY_SYSTEMS_PER_HOOK]; - SkaECSSystem* post_update_all_systems[MAX_ENTITY_SYSTEMS_PER_HOOK]; - SkaECSSystem* fixed_update_systems[MAX_ENTITY_SYSTEMS_PER_HOOK]; - SkaECSSystem* network_callback_systems[MAX_ENTITY_SYSTEMS_PER_HOOK]; -} EntitySystemData; - -void ska_ecs_system_insert_entity_into_system(SkaEntity entity, SkaECSSystem* system); -void ska_ecs_system_remove_entity_from_system(SkaEntity entity, SkaECSSystem* system); - -static EntitySystemData entitySystemData; - -void ska_ecs_system_initialize() { - // Initialize system data to 0 - entitySystemData = (EntitySystemData){0}; -} - -void ska_ecs_system_finalize() { - for (usize i = 0; i < entitySystemData.entity_systems_count; i++) { - ska_ecs_system_destroy(entitySystemData.entity_systems[i]); - entitySystemData.entity_systems[i] = NULL; - } -} - -SkaECSSystem* ska_ecs_system_create(const char* systemName) { - SkaECSSystem* newSystem = SKA_MEM_ALLOCATE(SkaECSSystem); - newSystem->name = ska_strdup(systemName); - return newSystem; -} - -SkaECSSystem* ska_ecs_system_create_from_template(SkaECSSystemTemplate* systemTemplate) { - SkaECSSystem* newSystem = SKA_MEM_ALLOCATE(SkaECSSystem); - newSystem->name = ska_strdup(systemTemplate->name); - newSystem->on_ec_system_register = systemTemplate->on_ec_system_register; - newSystem->on_ec_system_destroy = systemTemplate->on_ec_system_destroy; - newSystem->on_entity_registered_func = systemTemplate->on_entity_registered_func; - newSystem->on_entity_start_func = systemTemplate->on_entity_start_func; - newSystem->on_entity_end_func = systemTemplate->on_entity_end_func; - newSystem->on_entity_unregistered_func = systemTemplate->on_entity_unregistered_func; - newSystem->on_entity_entered_scene_func = systemTemplate->on_entity_entered_scene_func; - newSystem->render_func = systemTemplate->render_func; - newSystem->pre_update_all_func = systemTemplate->pre_update_all_func; - newSystem->post_update_all_func = systemTemplate->post_update_all_func; - newSystem->update_func = systemTemplate->update_func; - newSystem->fixed_update_func = systemTemplate->fixed_update_func; - newSystem->network_callback_func = systemTemplate->network_callback_func; - return newSystem; -} - -SkaECSSystemTemplate ska_ecs_system_create_default_template(const char* systemName) { - return (SkaECSSystemTemplate){ - .name = systemName, .on_ec_system_register = NULL, .on_ec_system_destroy = NULL, .on_entity_registered_func = NULL, .on_entity_start_func = NULL, .on_entity_end_func = NULL, - .on_entity_unregistered_func = NULL, .on_entity_entered_scene_func = NULL, .render_func = NULL, .pre_update_all_func = NULL, .post_update_all_func = NULL, - .update_func = NULL, .fixed_update_func = NULL, .network_callback_func = NULL - }; -} - -static SkaECSSystem* update_system_with_type_signature_string(SkaECSSystem* system, const char* signatures) { - // Take signature string, create flags, and add to system's component signature - static char typeNameBuffer[256]; - char* word = typeNameBuffer; - char* start = word; - for (const char* src = signatures; *src != '\0'; ++src) { - // Skip commas and whitespace - if (*src == ',') { - *word = '\0'; - const SkaComponentTypeInfo* typeInfo = ska_ecs_component_find_type_info(typeNameBuffer); - SKA_ASSERT_FMT(typeInfo, "Unable to get type info for '%s'", typeNameBuffer); - system->component_signature |= typeInfo->type; - word = start; - continue; - } else if (*src == ' ') { - continue; - } - *word++ = *src; - } - - *word = '\0'; - const SkaComponentTypeInfo* typeInfo = ska_ecs_component_find_type_info(typeNameBuffer); - SKA_ASSERT_FMT(typeInfo, "Unable to get type info for '%s'", typeNameBuffer); - system->component_signature |= typeInfo->type; - return system; -} - -SkaECSSystem* ska_ecs_system_create_with_signature_string(const char* systemName, const char* signatures) { - SkaECSSystem* newSystem = ska_ecs_system_create(systemName); - update_system_with_type_signature_string(newSystem, signatures); - return newSystem; -} - -SkaECSSystem* ska_ecs_system_create_from_template_with_signature_string(SkaECSSystemTemplate* systemTemplate, const char* signatures) { - SkaECSSystem* newSystem = ska_ecs_system_create_from_template(systemTemplate); - update_system_with_type_signature_string(newSystem, signatures); - return newSystem; -} - -void ska_ecs_system_destroy(SkaECSSystem* entitySystem) { - if (entitySystem->on_ec_system_destroy) { - entitySystem->on_ec_system_destroy(entitySystem); - } - SKA_MEM_FREE(entitySystem); -} - -void ska_ecs_system_register(SkaECSSystem* system) { - SKA_ASSERT_FMT(system != NULL, "Passed in system is NULL!"); - SKA_ASSERT_FMT(entitySystemData.entity_systems_count + 1 < SKA_ECS_MAX_COMPONENTS, "At system limit of '%d'", SKA_ECS_MAX_COMPONENTS); - entitySystemData.entity_systems[entitySystemData.entity_systems_count++] = system; - if (system->on_ec_system_register != NULL) { - system->on_ec_system_register(system); - } - if (system->on_entity_start_func != NULL) { - SKA_ASSERT_FMT(entitySystemData.on_entity_start_systems_count + 1 < MAX_ENTITY_SYSTEMS_PER_HOOK, "At system 'on_entity_start_func' limit of '%d'", MAX_ENTITY_SYSTEMS_PER_HOOK); - entitySystemData.on_entity_start_systems[entitySystemData.on_entity_start_systems_count++] = system; - } - if (system->on_entity_end_func != NULL) { - SKA_ASSERT_FMT(entitySystemData.on_entity_end_systems_count + 1 < MAX_ENTITY_SYSTEMS_PER_HOOK, "At system 'on_entity_end_func' limit of '%d'", MAX_ENTITY_SYSTEMS_PER_HOOK); - entitySystemData.on_entity_end_systems[entitySystemData.on_entity_end_systems_count++] = system; - } - if (system->on_entity_entered_scene_func != NULL) { - SKA_ASSERT_FMT(entitySystemData.on_entity_entered_scene_systems_count + 1 < MAX_ENTITY_SYSTEMS_PER_HOOK, "At system 'on_entity_entered_scene_func' limit of '%d'", MAX_ENTITY_SYSTEMS_PER_HOOK); - entitySystemData.on_entity_entered_scene_systems[entitySystemData.on_entity_entered_scene_systems_count++] = system; - } - if (system->render_func != NULL) { - SKA_ASSERT_FMT(entitySystemData.render_systems_count + 1 < MAX_ENTITY_SYSTEMS_PER_HOOK, "At system 'render_func' limit of '%d'", MAX_ENTITY_SYSTEMS_PER_HOOK); - entitySystemData.render_systems[entitySystemData.render_systems_count++] = system; - } - if (system->pre_update_all_func != NULL) { - SKA_ASSERT_FMT(entitySystemData.pre_update_all_systems_count + 1 < MAX_ENTITY_SYSTEMS_PER_HOOK, "At system 'pre_update_all_func' limit of '%d'", MAX_ENTITY_SYSTEMS_PER_HOOK); - entitySystemData.pre_update_all_systems[entitySystemData.pre_update_all_systems_count++] = system; - } - if (system->post_update_all_func != NULL) { - SKA_ASSERT_FMT(entitySystemData.post_update_all_systems_count + 1 < MAX_ENTITY_SYSTEMS_PER_HOOK, "At system 'post_update_all_func' limit of '%d'", MAX_ENTITY_SYSTEMS_PER_HOOK); - entitySystemData.post_update_all_systems[entitySystemData.post_update_all_systems_count++] = system; - } - if (system->update_func != NULL) { - SKA_ASSERT_FMT(entitySystemData.update_systems_count + 1 < MAX_ENTITY_SYSTEMS_PER_HOOK, "At system 'update_func' limit of '%d'", MAX_ENTITY_SYSTEMS_PER_HOOK); - entitySystemData.update_systems[entitySystemData.update_systems_count++] = system; - } - if (system->fixed_update_func != NULL) { - SKA_ASSERT_FMT(entitySystemData.fixed_update_systems_count + 1 < MAX_ENTITY_SYSTEMS_PER_HOOK, "At system 'fixed_update_func' limit of '%d'", MAX_ENTITY_SYSTEMS_PER_HOOK); - entitySystemData.fixed_update_systems[entitySystemData.fixed_update_systems_count++] = system; - } - if (system->network_callback_func != NULL) { - SKA_ASSERT_FMT(entitySystemData.network_callback_systems_count + 1 < MAX_ENTITY_SYSTEMS_PER_HOOK, "At system 'network_callback_func' limit of '%d'", MAX_ENTITY_SYSTEMS_PER_HOOK); - entitySystemData.network_callback_systems[entitySystemData.network_callback_systems_count++] = system; - } -} - -void ska_ecs_system_update_entity_signature_with_systems(SkaEntity entity) { - const SkaComponentType entityComponentSignature = ska_ecs_component_manager_get_component_signature(entity); - for (usize i = 0; i < entitySystemData.entity_systems_count; i++) { - if (SKA_FLAG_CONTAINS(entityComponentSignature, entitySystemData.entity_systems[i]->component_signature)) { - ska_ecs_system_insert_entity_into_system(entity, entitySystemData.entity_systems[i]); - } else { - ska_ecs_system_remove_entity_from_system(entity, entitySystemData.entity_systems[i]); - } - } -} - -void ska_ecs_system_event_entity_start(SkaEntity entity) { - const SkaComponentType entityComponentSignature = ska_ecs_component_manager_get_component_signature(entity); - for (usize i = 0; i < entitySystemData.on_entity_start_systems_count; i++) { - SkaECSSystem* ecsSystem = entitySystemData.on_entity_start_systems[i]; - if (SKA_FLAG_CONTAINS(entityComponentSignature, ecsSystem->component_signature)) { - ecsSystem->on_entity_start_func(ecsSystem, entity); - } - } -} - -void ska_ecs_system_event_entity_end(SkaEntity entity) { - // Notify scene exit observers before calling it on systems - // TODO: Consider hooks for components instead of direct node component references - const SkaComponentType entityComponentSignature = ska_ecs_component_manager_get_component_signature(entity); - for (usize i = 0; i < entitySystemData.on_entity_end_systems_count; i++) { - SkaECSSystem* ecsSystem = entitySystemData.on_entity_end_systems[i]; - if (SKA_FLAG_CONTAINS(entityComponentSignature, ecsSystem->component_signature)) { - ecsSystem->on_entity_end_func(ecsSystem, entity); - } - } -// NodeComponent* nodeComponent = (NodeComponent*)ska_ecs_component_manager_get_component_unchecked(entity, CreComponentDataIndex_NODE); -// if (nodeComponent != NULL) { -// // Note: Node events should not be created during this time -// ska_event_notify_observers(&nodeComponent->onSceneTreeExit, &(SkaSubjectNotifyPayload) { -// .data = &entity -// }); -// } -} - -void ska_ecs_system_event_entity_entered_scene(SkaEntity entity) { - // Notify scene enter observers before calling it on systems -// NodeComponent* nodeComponent = (NodeComponent*) ska_ecs_component_manager_get_component_unchecked(entity, CreComponentDataIndex_NODE); -// if (nodeComponent != NULL) { -// ska_event_notify_observers(&nodeComponent->onSceneTreeEnter, &(SkaSubjectNotifyPayload) { -// .data = &entity -// }); -// } - const SkaComponentType entityComponentSignature = ska_ecs_component_manager_get_component_signature(entity); - for (usize i = 0; i < entitySystemData.on_entity_entered_scene_systems_count; i++) { - SkaECSSystem* ecsSystem = entitySystemData.on_entity_entered_scene_systems[i]; - if (SKA_FLAG_CONTAINS(entityComponentSignature, ecsSystem->component_signature)) { - ecsSystem->on_entity_entered_scene_func(ecsSystem, entity); - } - } -} - -void ska_ecs_system_event_render_systems() { - for (usize i = 0; i < entitySystemData.render_systems_count; i++) { - SkaECSSystem* ecsSystem = entitySystemData.render_systems[i]; - ecsSystem->render_func(ecsSystem); - } -} - -void ska_ecs_system_event_pre_update_all_systems() { - for (usize i = 0; i < entitySystemData.pre_update_all_systems_count; i++) { - SkaECSSystem* ecsSystem = entitySystemData.pre_update_all_systems[i]; - ecsSystem->pre_update_all_func(ecsSystem); - } -} - -void ska_ecs_system_event_post_update_all_systems() { - for (usize i = 0; i < entitySystemData.post_update_all_systems_count; i++) { - SkaECSSystem* ecsSystem = entitySystemData.post_update_all_systems[i]; - ecsSystem->post_update_all_func(ecsSystem); - } -} - -void ska_ecs_system_event_update_systems(f32 deltaTime) { - for (usize i = 0; i < entitySystemData.update_systems_count; i++) { - SkaECSSystem* ecsSystem = entitySystemData.update_systems[i]; - ecsSystem->update_func(ecsSystem, deltaTime); - } -} - -void ska_ecs_system_event_fixed_update_systems(f32 deltaTime) { - for (usize i = 0; i < entitySystemData.fixed_update_systems_count; i++) { - SkaECSSystem* ecsSystem = entitySystemData.fixed_update_systems[i]; - ecsSystem->fixed_update_func(ecsSystem, deltaTime); - } -} - -void ska_ecs_system_event_network_callback(const char* message) { - for (usize i = 0; i < entitySystemData.network_callback_systems_count; i++) { - SkaECSSystem* ecsSystem = entitySystemData.network_callback_systems[i]; - ecsSystem->network_callback_func(ecsSystem, message); - } -} - -// --- Internal Functions --- // -bool ska_ecs_system_has_entity(SkaEntity entity, SkaECSSystem* system) { - for (usize i = 0; i < system->entity_count; i++) { - if (entity == system->entities[i]) { - return true; - } - } - return false; -} - -void ska_ecs_system_insert_entity_into_system(SkaEntity entity, SkaECSSystem* system) { - if (!ska_ecs_system_has_entity(entity, system)) { - system->entities[system->entity_count++] = entity; - if (system->on_entity_registered_func != NULL) { - system->on_entity_registered_func(system, entity); - } - } else { - ska_logger_internal_queue_message("Entity '%d' already in system '%s'", entity, system->name); - } -} - -void ska_ecs_system_remove_entity_from_system(SkaEntity entity, SkaECSSystem* system) { - for (usize i = 0; i < system->entity_count; i++) { - if (entity == system->entities[i]) { - // Entity found - if (i + 1 < SKA_MAX_ENTITIES) { - system->entities[i] = SKA_NULL_ENTITY; - } - if (system->on_entity_unregistered_func != NULL) { - system->on_entity_unregistered_func(system, entity); - } - - // Condense array - for (usize newIndex = i; i < system->entity_count; i++) { - if (system->entities[i] == SKA_NULL_ENTITY) { - // Early exit if 2 consecutive nulls - if (system->entities[i + 1] == SKA_NULL_ENTITY) { - break; - } - system->entities[i] = system->entities[i + 1]; - system->entities[i + 1] = SKA_NULL_ENTITY; - } - } - - system->entity_count--; - break; - } - } -} - -void ska_ecs_system_remove_entity_from_all_systems(SkaEntity entity) { - for (usize i = 0; i < entitySystemData.entity_systems_count; i++) { - ska_ecs_system_remove_entity_from_system(entity, entitySystemData.entity_systems[i]); - } -} diff --git a/old_seika/ecs/ec_system.h b/old_seika/ecs/ec_system.h deleted file mode 100644 index 98ba3cb..0000000 --- a/old_seika/ecs/ec_system.h +++ /dev/null @@ -1,110 +0,0 @@ -#pragma once - -#include "component.h" - -#define SKA_ECS_SYSTEM_CREATE(NAME, ...) \ -ska_ecs_system_create_with_signature_string(NAME, #__VA_ARGS__) - -#define SKA_ECS_SYSTEM_CREATE_FROM_TEMPLATE(TEMPLATE, ...) \ -ska_ecs_system_create_from_template_with_signature_string(TEMPLATE, #__VA_ARGS__) - -// Creates and register system from template -#define SKA_ECS_SYSTEM_REGISTER_FROM_TEMPLATE(TEMPLATE, ...) \ -ska_ecs_system_register(ska_ecs_system_create_from_template_with_signature_string(TEMPLATE, #__VA_ARGS__)) - -struct SkaECSSystem; - -typedef void (*OnECSystemRegister) (struct SkaECSSystem*); -typedef void (*OnECSystemDestroy) (struct SkaECSSystem*); -typedef void (*OnEntityRegisteredFunc) (struct SkaECSSystem*, SkaEntity); // init -typedef void (*OnEntityStartFunc) (struct SkaECSSystem*, SkaEntity); // Useful for after initialization functionality (such as entering a scene) -typedef void (*OnEntityEndFunc) (struct SkaECSSystem*, SkaEntity); // Useful for before deletion functionality (such as leaving a scene) -typedef void (*OnEntityUnRegisteredFunc) (struct SkaECSSystem*, SkaEntity); // delete -typedef void (*OnEntityEnteredSceneFunc) (struct SkaECSSystem*, SkaEntity); // When entity enters a scene (after _start() is called) -typedef void (*RenderFunc) (struct SkaECSSystem*); -typedef void (*PreProcessAllFunc) (struct SkaECSSystem*); -typedef void (*PostProcessAllFunc) (struct SkaECSSystem*); -typedef void (*UpdateFunc) (struct SkaECSSystem*, float); -typedef void (*FixedUpdateFunc) (struct SkaECSSystem*, float); -typedef void (*NetworkCallbackFunc) (struct SkaECSSystem*, const char*); - -typedef struct SkaECSSystem { - char* name; - // Event callbacks - OnECSystemRegister on_ec_system_register; // happens on register - OnECSystemDestroy on_ec_system_destroy; - OnEntityRegisteredFunc on_entity_registered_func; - OnEntityStartFunc on_entity_start_func; - OnEntityEndFunc on_entity_end_func; - OnEntityUnRegisteredFunc on_entity_unregistered_func; - OnEntityEnteredSceneFunc on_entity_entered_scene_func; - RenderFunc render_func; - PreProcessAllFunc pre_update_all_func; - PostProcessAllFunc post_update_all_func; - UpdateFunc update_func; - FixedUpdateFunc fixed_update_func; - NetworkCallbackFunc network_callback_func; - SkaComponentType component_signature; - usize entity_count; - // Keeps track of entities that match a component signature - SkaEntity entities[SKA_MAX_ENTITIES]; -} SkaECSSystem; - -typedef struct SkaECSSystemTemplate { - const char* name; - OnECSystemRegister on_ec_system_register; - OnECSystemDestroy on_ec_system_destroy; - OnEntityRegisteredFunc on_entity_registered_func; - OnEntityStartFunc on_entity_start_func; - OnEntityEndFunc on_entity_end_func; - OnEntityUnRegisteredFunc on_entity_unregistered_func; - OnEntityEnteredSceneFunc on_entity_entered_scene_func; - RenderFunc render_func; - PreProcessAllFunc pre_update_all_func; - PostProcessAllFunc post_update_all_func; - UpdateFunc update_func; - FixedUpdateFunc fixed_update_func; - NetworkCallbackFunc network_callback_func; -} SkaECSSystemTemplate; - -// example system template -#define SKA_ECS_SYSTEM_TEMPLATE_STRUCT SKA_STRUCT_LITERAL(SkaECSSystemTemplate){ \ - .name = "example template system", \ - .on_ec_system_register = NULL, \ - .on_ec_system_destroy = NULL, \ - .on_entity_registered_func = NULL, \ - .on_entity_start_func = NULL, \ - .on_entity_end_func = NULL, \ - .on_entity_unregistered_func = NULL, \ - .on_entity_entered_scene_func = NULL, \ - .render_func = NULL, \ - .pre_update_all_func = NULL, \ - .post_update_all_func = NULL, \ - .update_func = NULL, \ - .fixed_update_func = NULL, \ - .network_callback_func = NULL \ -} - -void ska_ecs_system_initialize(); -void ska_ecs_system_finalize(); -SkaECSSystem* ska_ecs_system_create(const char* systemName); -SkaECSSystem* ska_ecs_system_create_from_template(SkaECSSystemTemplate* systemTemplate); -SkaECSSystem* ska_ecs_system_create_with_signature_string(const char* systemName, const char* signatures); -SkaECSSystem* ska_ecs_system_create_from_template_with_signature_string(SkaECSSystemTemplate* systemTemplate, const char* signatures); -SkaECSSystemTemplate ska_ecs_system_create_default_template(const char* systemName); -void ska_ecs_system_destroy(SkaECSSystem* entitySystem); -void ska_ecs_system_register(SkaECSSystem* system); -void ska_ecs_system_update_entity_signature_with_systems(SkaEntity entity); -void ska_ecs_system_remove_entity_from_all_systems(SkaEntity entity); -bool ska_ecs_system_has_entity(SkaEntity entity, SkaECSSystem* system); - -// Event functions -void ska_ecs_system_event_entity_start(SkaEntity entity); -void ska_ecs_system_event_entity_end(SkaEntity entity); -void ska_ecs_system_event_entity_entered_scene(SkaEntity entity); -void ska_ecs_system_event_render_systems(); -void ska_ecs_system_event_pre_update_all_systems(); -void ska_ecs_system_event_post_update_all_systems(); -void ska_ecs_system_event_update_systems(f32 deltaTime); -void ska_ecs_system_event_fixed_update_systems(f32 deltaTime); -void ska_ecs_system_event_network_callback(const char* message); diff --git a/old_seika/ecs/ecs.c b/old_seika/ecs/ecs.c deleted file mode 100644 index e269fe2..0000000 --- a/old_seika/ecs/ecs.c +++ /dev/null @@ -1,13 +0,0 @@ -#include "ecs.h" - -void ska_ecs_initialize() { - ska_ecs_entity_initialize(); - ska_ecs_system_initialize(); - ska_ecs_component_manager_initialize(); -} - -void ska_ecs_finalize() { - ska_ecs_entity_finalize(); - ska_ecs_component_manager_finalize(); - ska_ecs_system_finalize(); -} diff --git a/old_seika/ecs/ecs.h b/old_seika/ecs/ecs.h deleted file mode 100644 index 7b7e0a0..0000000 --- a/old_seika/ecs/ecs.h +++ /dev/null @@ -1,6 +0,0 @@ -#pragma once - -#include "ec_system.h" - -void ska_ecs_initialize(); -void ska_ecs_finalize(); diff --git a/old_seika/ecs/entity.c b/old_seika/ecs/entity.c deleted file mode 100644 index bfb6b04..0000000 --- a/old_seika/ecs/entity.c +++ /dev/null @@ -1,43 +0,0 @@ -#include "entity.h" -#include "seika/data_structures/queue.h" -#include "seika/assert.h" - -static SkaQueue* entityIdQueue = NULL; -static SkaEntity entityIdCounter = 0; -static usize activeEntityCount = 0; - -void ska_ecs_entity_initialize() { - SKA_ASSERT(entityIdQueue == NULL); - entityIdQueue = ska_queue_create(SKA_MAX_ENTITIES, SKA_NULL_ENTITY); - while (entityIdCounter < 100) { - ska_queue_enqueue(entityIdQueue, entityIdCounter++); - } -} - -void ska_ecs_entity_finalize() { - SKA_ASSERT(entityIdQueue); - ska_queue_destroy(entityIdQueue); - entityIdQueue = NULL; - entityIdCounter = 0; - activeEntityCount = 0; -} - -SkaEntity ska_ecs_entity_create() { - SKA_ASSERT(entityIdQueue); - if (ska_queue_is_empty(entityIdQueue)) { - SKA_ASSERT_FMT(entityIdCounter < SKA_MAX_ENTITIES, "Reached maxed entities ids to create, considering increasing SKA_MAX_ENTITIES!"); - ska_queue_enqueue(entityIdQueue, entityIdCounter++); - } - activeEntityCount++; - return ska_queue_dequeue(entityIdQueue); -} - -void ska_ecs_entity_return(SkaEntity entity) { - SKA_ASSERT(entityIdQueue); - ska_queue_enqueue(entityIdQueue,entity); - activeEntityCount--; -} - -usize ska_ecs_entity_get_active_count() { - return activeEntityCount; -} diff --git a/old_seika/ecs/entity.h b/old_seika/ecs/entity.h deleted file mode 100644 index ec958b0..0000000 --- a/old_seika/ecs/entity.h +++ /dev/null @@ -1,24 +0,0 @@ -#pragma once - -#include - -#include "seika/defines.h" - -// Entity is defined as a unsigned 32-bit integer - -// Gives a chance for users to set own max entities -#ifndef SKA_MAX_ENTITIES -#define SKA_MAX_ENTITIES 200000 // starting with 200,000 for now -#endif - -#define SKA_NULL_ENTITY UINT32_MAX - -typedef uint32 SkaEntity; - -void ska_ecs_entity_initialize(); -void ska_ecs_entity_finalize(); -// Pops entity from the queue -SkaEntity ska_ecs_entity_create(); -// Push entity to the queue -void ska_ecs_entity_return(SkaEntity entity); -usize ska_ecs_entity_get_active_count(); diff --git a/old_seika/event.c b/old_seika/event.c deleted file mode 100644 index b983a2c..0000000 --- a/old_seika/event.c +++ /dev/null @@ -1,47 +0,0 @@ -#include "event.h" - -#include "seika/memory.h" -#include "seika/assert.h" -#include "seika/data_structures/array_utils.h" - -//--- Observer ---// -SkaObserver* ska_observer_new(SkaObserverOnNotify onNotifyFunc) { - SKA_ASSERT(onNotifyFunc != NULL); - SkaObserver* observer = SKA_MEM_ALLOCATE(SkaObserver); - observer->on_notify = onNotifyFunc; - return observer; -} - -void ska_observer_delete(SkaObserver* observer) { - SKA_MEM_FREE(observer); -} - -//--- Event ---// -SkaEvent* ska_event_new() { - SkaEvent* event = SKA_MEM_ALLOCATE(SkaEvent); - event->observerCount = 0; - return event; -} - -void ska_event_delete(SkaEvent* event) { - SKA_MEM_FREE(event); -} - -bool ska_event_register_observer(SkaEvent* event, SkaObserver* observer) { - SKA_ASSERT(event != NULL); - SKA_ASSERT(observer != NULL); - SKA_ASSERT_FMT(event->observerCount + 1 < SKA_MAX_OBSERVERS, "Reached max observer count, consider increasing 'SKA_MAX_OBSERVERS'!"); - event->observers[event->observerCount++] = observer; - return true; -} - -bool ska_event_unregister_observer(SkaEvent* event, SkaObserver* observer) { - SKA_ARRAY_UTILS_REMOVE_ARRAY_ITEM(event->observers, event->observerCount, observer, NULL); - return true; -} - -void ska_event_notify_observers(SkaEvent* event, SkaSubjectNotifyPayload* payload) { - for (usize i = 0; i < event->observerCount; i++) { - event->observers[i]->on_notify(payload); - } -} diff --git a/old_seika/event.h b/old_seika/event.h deleted file mode 100644 index 54b7ca4..0000000 --- a/old_seika/event.h +++ /dev/null @@ -1,31 +0,0 @@ -#pragma once - -#include "defines.h" - -#define SKA_MAX_OBSERVERS 8 - -typedef struct SkaSubjectNotifyPayload { - void* data; // Primary data, be sure to cast properly -} SkaSubjectNotifyPayload; - -typedef void (*SkaObserverOnNotify)(SkaSubjectNotifyPayload*); - -// An observer that can subscribe to a subject -typedef struct SkaObserver { - SkaObserverOnNotify on_notify; -} SkaObserver; - -SkaObserver* ska_observer_new(SkaObserverOnNotify onNotifyFunc); -void ska_observer_delete(SkaObserver* observer); - -// A subscribable event -typedef struct SkaEvent { - usize observerCount; - SkaObserver* observers[SKA_MAX_OBSERVERS]; -} SkaEvent; - -SkaEvent* ska_event_new(); -void ska_event_delete(SkaEvent* event); -bool ska_event_register_observer(SkaEvent* event, SkaObserver* observer); -bool ska_event_unregister_observer(SkaEvent* event, SkaObserver* observer); -void ska_event_notify_observers(SkaEvent* event, SkaSubjectNotifyPayload* payload); diff --git a/old_seika/file_system.c b/old_seika/file_system.c deleted file mode 100644 index 2b11391..0000000 --- a/old_seika/file_system.c +++ /dev/null @@ -1,190 +0,0 @@ -#include "file_system.h" - -#ifdef _WIN32 -#include -#include -#else -#include -#endif - -#include -#include - -#if defined(_MSC_VER) -#include -#include -#else -#include -#include - -#endif - - -#include - -#include "logger.h" -#include "seika/string.h" -#include "seika/memory.h" - -#ifdef _MSC_VER -#pragma warning(disable : 4996) // for fopen -#endif - -#define CHAR_ARRAY_MAX_BUFFER_SIZE 256 - -void ska_fs_get_cwd_array(char* array, usize size) { - if (getcwd(array, (int) size) != NULL) { - return; - } -} - -bool ska_fs_chdir(const char* dirPath) { - char currentWorkingPath[CHAR_ARRAY_MAX_BUFFER_SIZE]; - ska_fs_get_cwd_array(currentWorkingPath, CHAR_ARRAY_MAX_BUFFER_SIZE); - if (strcmp(currentWorkingPath, dirPath) == 0) { - ska_logger_warn("Attempting to change to the same directory at path '%s'", currentWorkingPath); - return false; - } - if (chdir(dirPath) == 0) { - return true; - } - ska_logger_error("Failed to change directory to path '%s'", dirPath); - return false; -} - -char* ska_fs_get_cwd() { - char cwd[CHAR_ARRAY_MAX_BUFFER_SIZE]; - if (getcwd(cwd, sizeof(cwd)) != NULL) { - return ska_strdup(cwd); - } - return NULL; -} - -void ska_fs_print_cwd() { - char cwd[CHAR_ARRAY_MAX_BUFFER_SIZE]; - if (getcwd(cwd, sizeof(cwd)) != NULL) { - ska_logger_info("Current working directory: %s\n", cwd); - } else { - ska_logger_error("Not able to get current working directory!"); - } -} - -usize ska_fs_get_file_size(const char* filePath) { -#ifdef _WIN32 - HANDLE hFile = CreateFile(filePath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); - if (hFile == INVALID_HANDLE_VALUE) { - ska_logger_error("Error invalid handle value when getting file size at path '%s'", filePath); - return 0; - } - - LARGE_INTEGER size; - if (!GetFileSizeEx(hFile, &size)) { - CloseHandle(hFile); - ska_logger_error("Error getting file size at path '%s'", filePath); - return 0; - } - - CloseHandle(hFile); - return (usize) size.QuadPart; -#else - struct stat st; - stat(filePath, &st); - return (usize) st.st_size; -#endif -} - -bool ska_fs_write_to_file(const char* filePath, const char* contents) { - FILE* fp = fopen(filePath, "w"); - if (fp) { - fprintf(fp, "%s\n", contents); - fclose(fp); - return true; - } - return false; -} - -char* ska_fs_read_file_contents(const char* filePath, usize* sz) { - char* buffer = NULL; - FILE* fp = fopen(filePath, "rb"); - usize readSize = 0; - if (fp) { - readSize = ska_fs_get_file_size(filePath); - // Update buffer - buffer = (char*)SKA_MEM_ALLOCATE_SIZE(readSize + 1); - if (buffer != NULL) { - fread(buffer, 1, readSize, fp); - buffer[readSize] = '\0'; - } - fclose(fp); - } - if (sz != NULL) { - *sz = readSize; - } - return buffer; -} - -char* ska_fs_read_file_contents_without_raw(const char* filePath, usize* sz) { - char* buffer = NULL; - FILE* fp = fopen(filePath, "r"); - usize readSize = 0; - if (fp) { - readSize = ska_fs_get_file_size(filePath); - // Update buffer - buffer = (char*)SKA_MEM_ALLOCATE_SIZE(readSize + 1); - if (buffer != NULL) { - usize bytesRead = 0; - while (bytesRead < readSize) { - const int maxCount = (int)(readSize - bytesRead + 1); - if (fgets(buffer + bytesRead, maxCount, fp) == NULL) { - break; - } - bytesRead += strlen(buffer + bytesRead); - if (bytesRead > readSize) { - // Handle error: file contains more data than expected - break; - } - } - buffer[readSize] = '\0'; - } - fclose(fp); - } - if (sz != NULL) { - *sz = readSize; - } - return buffer; -} - -bool ska_fs_does_file_exist(const char* filePath) { - FILE* fp = fopen(filePath, "r"); - if (fp) { - fclose(fp); - return true; - } - return false; -} - -bool ska_fs_does_dir_exist(const char* dirPath) { -#if defined(WIN32) || defined(WIN64) - if (strnlen(dirPath, MAX_PATH + 1) > MAX_PATH) { - return false; - } - DWORD result = GetFileAttributesA(dirPath); - return (result != INVALID_FILE_ATTRIBUTES && (result & FILE_ATTRIBUTE_DIRECTORY)); -#else - struct stat stats; - if (stat(dirPath, &stats) == 0) { - return S_ISDIR(stats.st_mode); - } - return false; -#endif -} - -char* ska_fs_get_user_save_path(const char* orgName, const char* applicationName, const char* savePath) { - char buffer[CHAR_ARRAY_MAX_BUFFER_SIZE]; - char* filePath = SDL_GetPrefPath(orgName, applicationName); - strcpy(buffer, filePath); - strcat(buffer, savePath); - char* fullUserSavePath = ska_strdup(buffer); - SDL_free(filePath); - return fullUserSavePath; -} diff --git a/old_seika/file_system.h b/old_seika/file_system.h deleted file mode 100644 index f9b6a2b..0000000 --- a/old_seika/file_system.h +++ /dev/null @@ -1,26 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -#include "defines.h" - -// Change directory -bool ska_fs_chdir(const char* dirPath); -// Get current working directory -char* ska_fs_get_cwd(); -// Print current working directory -void ska_fs_print_cwd(); - -usize ska_fs_get_file_size(const char* filePath); -char* ska_fs_read_file_contents(const char* filePath, usize* sz); -char* ska_fs_read_file_contents_without_raw(const char* filePath, usize* sz); -bool ska_fs_write_to_file(const char* filePath, const char* contents); -bool ska_fs_does_file_exist(const char* filePath); -bool ska_fs_does_dir_exist(const char* dirPath); -char* ska_fs_get_user_save_path(const char* orgName, const char* applicationName, const char* savePath); - -#ifdef __cplusplus -} -#endif diff --git a/old_seika/flag_utils.h b/old_seika/flag_utils.h deleted file mode 100644 index abef55e..0000000 --- a/old_seika/flag_utils.h +++ /dev/null @@ -1,24 +0,0 @@ -#pragma once - -// Contains flag macros... - -// Check if 'FLAGS' contains all the flags specified in 'REQUIRED_FLAGS' -#define SKA_FLAG_CONTAINS(FLAGS, REQUIRED_FLAGS) (((FLAGS) & (REQUIRED_FLAGS)) == (REQUIRED_FLAGS)) - -// Check if 'FLAG' contains any of the flags specified in 'REQUIRED_FLAGS' -#define SKA_HAS_FLAG(FLAG, REQUIRED_FLAGS) ((FLAG) & (REQUIRED_FLAGS)) - -// Check if 'FLAGS' contains none of the flags specified in 'FORBIDDEN_FLAGS' -#define SKA_HAS_NO_FLAG(FLAGS, FORBIDDEN_FLAGS) (((FLAGS) & (FORBIDDEN_FLAGS)) == 0) - -// Check if 'FLAGS' contains exactly one of the flags specified in 'REQUIRED_FLAGS' -#define SKA_HAS_EXACTLY_ONE_FLAG(FLAGS, REQUIRED_FLAGS) (HAS_ALL_FLAGS(FLAGS, REQUIRED_FLAGS) && ((FLAGS) != 0)) - -// Check if 'FLAGS' contains none of the flags specified in 'REQUIRED_FLAGS' -#define SKA_HAS_NONE_OF_FLAGS(FLAGS, REQUIRED_FLAGS) (((FLAGS) & (REQUIRED_FLAGS)) == 0) - -// Add 'NEW_FLAGS' to 'FLAGS' -#define SKA_ADD_FLAGS(FLAGS, NEW_FLAGS) ((FLAGS) |= (NEW_FLAGS)) - -// Remove 'REMOVE_FLAGS' from 'FLAGS' -#define SKA_REMOVE_FLAGS(FLAGS, REMOVE_FLAGS) ((FLAGS) &= ~(REMOVE_FLAGS)) diff --git a/old_seika/input/input.c b/old_seika/input/input.c deleted file mode 100644 index 172e778..0000000 --- a/old_seika/input/input.c +++ /dev/null @@ -1,567 +0,0 @@ -#include "input.h" -#include "seika/assert.h" -#include "seika/memory.h" - -#define SKA_INPUT_MAX_KEY_STATE_CLEANUP_SIZE 16 - -typedef struct SkaAxisInputValues { - SkaVector2 left; - SkaVector2 right; -} SkaAxisInputValues; - -typedef struct SkaInputKeyState { - bool isPressed; - bool isJustPressed; - bool isJustReleased; - f32 strength; - SkaAxisInputValues prevAxisValues[SKA_INPUT_MAX_DEVICES]; -} SkaInputKeyState; - -typedef struct SkaInputStateCleanup { - SkaInputKey key; - SkaInputDeviceIndex deviceIndex; -} SkaInputStateCleanup; - -typedef struct SkaInputActionData { - SkaInputAction action; - SkaInputActionHandle handle; -} SkaInputActionData; - -typedef struct SkaInputState { - SkaInputKeyState inputKeyState[SKA_INPUT_MAX_DEVICES][SkaInputKey_NUMBER_OF_KEYS]; - - SkaAxisInputValues prevAxisInputs[SKA_INPUT_MAX_DEVICES]; - - SkaInputStateCleanup cleanupKeyStateJustPressed[SKA_INPUT_MAX_KEY_STATE_CLEANUP_SIZE]; - SkaInputStateCleanup cleanupKeyStateJustReleased[SKA_INPUT_MAX_KEY_STATE_CLEANUP_SIZE]; - usize cleanupKeyStateJustPressedCount; - usize cleanupKeyStateJustReleasedCount; - - SkaInputActionHandle inputActionHandleIndex; - SkaInputActionData inputActionData[SKA_INPUT_MAX_DEVICES][SKA_INPUT_MAX_INPUT_ACTIONS]; -} SkaInputState; - -#define DEFAULT_INPUT_STATE {0} - -static SkaInputState inputState = DEFAULT_INPUT_STATE; -static SkaMouse globalMouse = {0}; - -static SkaInputKey get_key_from_2d_axis_key(SkaInputKey axis2DKey, SkaAxisInputValues* axisInputValues, f32 axisValue); -static void set_prev_input_axis_value(SkaInputKey key, SkaAxisInputValues* axisInputValues, f32 axisValue); -static void update_axis_key_state(SkaInputKey key, SkaInputInteractionStatus interactionStatus, f32 axisValue, SkaInputDeviceIndex deviceIndex); - -const char* ska_input_key_to_string(SkaInputKey key) { - static const char* keyNames[SkaInputKey_NUMBER_OF_KEYS] = { - [SkaInputKey_INVALID] = "Invalid", - // Gamepad - [SkaInputKey_GAMEPAD_DPAD_DOWN] = "Gamepad Dpad Down", - [SkaInputKey_GAMEPAD_DPAD_UP] = "Gamepad Dpad Up", - [SkaInputKey_GAMEPAD_DPAD_LEFT] = "Gamepad Dpad Left", - [SkaInputKey_GAMEPAD_DPAD_RIGHT] = "Gamepad Dpad Right", - [SkaInputKey_GAMEPAD_FACE_BUTTON_NORTH] = "Gamepad Face Button North", - [SkaInputKey_GAMEPAD_FACE_BUTTON_SOUTH] = "Gamepad Face Button South", - [SkaInputKey_GAMEPAD_FACE_BUTTON_EAST] = "Gamepad Face Button East", - [SkaInputKey_GAMEPAD_FACE_BUTTON_WEST] = "Gamepad Face Button West", - [SkaInputKey_GAMEPAD_START] = "Gamepad Start", - [SkaInputKey_GAMEPAD_BACK] = "Gamepad Back", - [SkaInputKey_GAMEPAD_LEFT_SHOULDER] = "Gamepad Left Shoulder", - [SkaInputKey_GAMEPAD_LEFT_TRIGGER] = "Gamepad Left Trigger", - [SkaInputKey_GAMEPAD_LEFT_ANALOG_BUTTON] = "Gamepad Left Analog Button", - [SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X] = "Gamepad Left Analog 2D Axis X", - [SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y] = "Gamepad Left Analog 2D Axis Y", - [SkaInputKey_GAMEPAD_RIGHT_SHOULDER] = "Gamepad Right Shoulder", - [SkaInputKey_GAMEPAD_RIGHT_TRIGGER] = "Gamepad Right Trigger", - [SkaInputKey_GAMEPAD_RIGHT_ANALOG_BUTTON] = "Gamepad Right Analog Button", - [SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X] = "Gamepad Right Analog 2D Axis X", - [SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_Y] = "Gamepad Right Analog 2D Axis Y", - [SkaInputKey_GAMEPAD_LEFT_ANALOG_LEFT] = "Gamepad Left Analog Left", - [SkaInputKey_GAMEPAD_LEFT_ANALOG_RIGHT] = "Gamepad Left Analog Right", - [SkaInputKey_GAMEPAD_LEFT_ANALOG_UP] = "Gamepad Left Analog Up", - [SkaInputKey_GAMEPAD_LEFT_ANALOG_DOWN] = "Gamepad Left Analog Down", - [SkaInputKey_GAMEPAD_RIGHT_ANALOG_LEFT] = "Gamepad Right Analog Left", - [SkaInputKey_GAMEPAD_RIGHT_ANALOG_RIGHT] = "Gamepad Right Analog Right", - [SkaInputKey_GAMEPAD_RIGHT_ANALOG_UP] = "Gamepad Right Analog Up", - [SkaInputKey_GAMEPAD_RIGHT_ANALOG_DOWN] = "Gamepad Right Analog Down", - // Keyboard - [SkaInputKey_KEYBOARD_TAB] = "Tab", - [SkaInputKey_KEYBOARD_LEFT] = "Left", - [SkaInputKey_KEYBOARD_RIGHT] = "Right", - [SkaInputKey_KEYBOARD_UP] = "Up", - [SkaInputKey_KEYBOARD_DOWN] = "Down", - [SkaInputKey_KEYBOARD_PAGE_DOWN] = "Page Down", - [SkaInputKey_KEYBOARD_PAGE_UP] = "Page Up", - [SkaInputKey_KEYBOARD_HOME] = "Home", - [SkaInputKey_KEYBOARD_END] = "End", - [SkaInputKey_KEYBOARD_INSERT] = "Insert", - [SkaInputKey_KEYBOARD_DELETE] = "Delete", - [SkaInputKey_KEYBOARD_BACKSPACE] = "Backspace", - [SkaInputKey_KEYBOARD_SPACE] = "Space", - [SkaInputKey_KEYBOARD_RETURN] = "Return", - [SkaInputKey_KEYBOARD_ESCAPE] = "Escape", - [SkaInputKey_KEYBOARD_QUOTE] = "Quote", - [SkaInputKey_KEYBOARD_COMMA] = "Comma", - [SkaInputKey_KEYBOARD_MINUS] = "Minus", - [SkaInputKey_KEYBOARD_PERIOD] = "Period", - [SkaInputKey_KEYBOARD_SLASH] = "Slash", - [SkaInputKey_KEYBOARD_SEMICOLON] = "Semicolon", - [SkaInputKey_KEYBOARD_EQUALS] = "Equals", - [SkaInputKey_KEYBOARD_LEFT_BRACKET] = "Left Bracket", - [SkaInputKey_KEYBOARD_RIGHT_BRACKET] = "Right Bracket", - [SkaInputKey_KEYBOARD_BACKSLASH] = "Backslash", - [SkaInputKey_KEYBOARD_BACKQUOTE] = "Backquote", - [SkaInputKey_KEYBOARD_CAPS_LOCK] = "Caps Lock", - [SkaInputKey_KEYBOARD_SCROLL_LOCK] = "Scroll Lock", - [SkaInputKey_KEYBOARD_NUM_LOCK_CLEAR] = "Num Lock Clear", - [SkaInputKey_KEYBOARD_PRINT_SCREEN] = "Print Screen", - [SkaInputKey_KEYBOARD_PAUSE] = "Pause", - [SkaInputKey_KEYBOARD_KEYPAD_0] = "Keypad 0", - [SkaInputKey_KEYBOARD_KEYPAD_1] = "Keypad 1", - [SkaInputKey_KEYBOARD_KEYPAD_2] = "Keypad 2", - [SkaInputKey_KEYBOARD_KEYPAD_3] = "Keypad 3", - [SkaInputKey_KEYBOARD_KEYPAD_4] = "Keypad 4", - [SkaInputKey_KEYBOARD_KEYPAD_5] = "Keypad 5", - [SkaInputKey_KEYBOARD_KEYPAD_6] = "Keypad 6", - [SkaInputKey_KEYBOARD_KEYPAD_7] = "Keypad 7", - [SkaInputKey_KEYBOARD_KEYPAD_8] = "Keypad 8", - [SkaInputKey_KEYBOARD_KEYPAD_9] = "Keypad 9", - [SkaInputKey_KEYBOARD_KEYPAD_PERIOD] = "Keypad Period", - [SkaInputKey_KEYBOARD_KEYPAD_DIVIDE] = "Keypad Divide", - [SkaInputKey_KEYBOARD_KEYPAD_MULTIPLY] = "Keypad Multiply", - [SkaInputKey_KEYBOARD_KEYPAD_MINUS] = "Keypad Minus", - [SkaInputKey_KEYBOARD_KEYPAD_PLUS] = "Keypad Plus", - [SkaInputKey_KEYBOARD_KEYPAD_ENTER] = "Keypad Enter", - [SkaInputKey_KEYBOARD_KEYPAD_EQUALS] = "Keypad Equals", - [SkaInputKey_KEYBOARD_LEFT_CONTROL] = "Left Control", - [SkaInputKey_KEYBOARD_LEFT_SHIFT] = "Left Shift", - [SkaInputKey_KEYBOARD_LEFT_ALT] = "Left Alt", - [SkaInputKey_KEYBOARD_LEFT_GUI] = "Left GUI", - [SkaInputKey_KEYBOARD_RIGHT_CONTROL] = "Right Control", - [SkaInputKey_KEYBOARD_RIGHT_SHIFT] = "Right Shift", - [SkaInputKey_KEYBOARD_RIGHT_ALT] = "Right Alt", - [SkaInputKey_KEYBOARD_RIGHT_GUI] = "Right GUI", - [SkaInputKey_KEYBOARD_APPLICATION] = "Application", - [SkaInputKey_KEYBOARD_NUM_0] = "0", - [SkaInputKey_KEYBOARD_NUM_1] = "1", - [SkaInputKey_KEYBOARD_NUM_2] = "2", - [SkaInputKey_KEYBOARD_NUM_3] = "3", - [SkaInputKey_KEYBOARD_NUM_4] = "4", - [SkaInputKey_KEYBOARD_NUM_5] = "5", - [SkaInputKey_KEYBOARD_NUM_6] = "6", - [SkaInputKey_KEYBOARD_NUM_7] = "7", - [SkaInputKey_KEYBOARD_NUM_8] = "8", - [SkaInputKey_KEYBOARD_NUM_9] = "9", - [SkaInputKey_KEYBOARD_A] = "A", - [SkaInputKey_KEYBOARD_B] = "B", - [SkaInputKey_KEYBOARD_C] = "C", - [SkaInputKey_KEYBOARD_D] = "D", - [SkaInputKey_KEYBOARD_E] = "E", - [SkaInputKey_KEYBOARD_F] = "F", - [SkaInputKey_KEYBOARD_G] = "G", - [SkaInputKey_KEYBOARD_H] = "H", - [SkaInputKey_KEYBOARD_I] = "I", - [SkaInputKey_KEYBOARD_J] = "J", - [SkaInputKey_KEYBOARD_K] = "K", - [SkaInputKey_KEYBOARD_L] = "L", - [SkaInputKey_KEYBOARD_M] = "M", - [SkaInputKey_KEYBOARD_N] = "N", - [SkaInputKey_KEYBOARD_O] = "O", - [SkaInputKey_KEYBOARD_P] = "P", - [SkaInputKey_KEYBOARD_Q] = "Q", - [SkaInputKey_KEYBOARD_R] = "R", - [SkaInputKey_KEYBOARD_S] = "S", - [SkaInputKey_KEYBOARD_T] = "T", - [SkaInputKey_KEYBOARD_U] = "U", - [SkaInputKey_KEYBOARD_V] = "V", - [SkaInputKey_KEYBOARD_W] = "W", - [SkaInputKey_KEYBOARD_X] = "X", - [SkaInputKey_KEYBOARD_Y] = "Y", - [SkaInputKey_KEYBOARD_Z] = "Z", - [SkaInputKey_KEYBOARD_F1] = "F1", - [SkaInputKey_KEYBOARD_F2] = "F2", - [SkaInputKey_KEYBOARD_F3] = "F3", - [SkaInputKey_KEYBOARD_F4] = "F4", - [SkaInputKey_KEYBOARD_F5] = "F5", - [SkaInputKey_KEYBOARD_F6] = "F6", - [SkaInputKey_KEYBOARD_F7] = "F7", - [SkaInputKey_KEYBOARD_F8] = "F8", - [SkaInputKey_KEYBOARD_F9] = "F9", - [SkaInputKey_KEYBOARD_F10] = "F10", - [SkaInputKey_KEYBOARD_F11] = "F11", - [SkaInputKey_KEYBOARD_F12] = "F12", - [SkaInputKey_KEYBOARD_F13] = "F13", - [SkaInputKey_KEYBOARD_F14] = "F14", - [SkaInputKey_KEYBOARD_F15] = "F15", - [SkaInputKey_KEYBOARD_F16] = "F16", - [SkaInputKey_KEYBOARD_F17] = "F17", - [SkaInputKey_KEYBOARD_F18] = "F18", - [SkaInputKey_KEYBOARD_F19] = "F19", - [SkaInputKey_KEYBOARD_F20] = "F20", - [SkaInputKey_KEYBOARD_F21] = "F21", - [SkaInputKey_KEYBOARD_F22] = "F22", - [SkaInputKey_KEYBOARD_F23] = "F23", - [SkaInputKey_KEYBOARD_F24] = "F24", - [SkaInputKey_KEYBOARD_APP_FORWARD] = "App Forward", - [SkaInputKey_KEYBOARD_APP_BACK] = "App Back", - // Mouse - [SkaInputKey_MOUSE_BUTTON_LEFT] = "Mouse Button Left", - [SkaInputKey_MOUSE_BUTTON_RIGHT] = "Mouse Button Right", - [SkaInputKey_MOUSE_BUTTON_MIDDLE] = "Mouse Button Middle", - }; - return keyNames[key]; -} - -SkaInputKey ska_input_string_to_key(const char* keyName) { - for (SkaInputKey key = 0; key < SkaInputKey_NUMBER_OF_KEYS; ++key) { - if (strcmp(keyName, ska_input_key_to_string(key)) == 0) { - return key; - } - } - return SkaInputKey_INVALID; // Return invalid if not found -} - -bool ska_input_is_keyboard_key(SkaInputKey key) { - return key >= SKA_INPUT_KEY_KEYBOARD_ENUM_START && key <= SKA_INPUT_KEY_KEYBOARD_ENUM_END; -} - -bool ska_input_is_mouse_key(SkaInputKey key) { - return key >= SKA_INPUT_KEY_MOUSE_ENUM_START && key <= SKA_INPUT_KEY_MOUSE_ENUM_END; -} - -bool ska_input_is_gamepad_key(SkaInputKey key) { - return key >= SKA_INPUT_KEY_GAMEPAD_ENUM_START && key <= SKA_INPUT_KEY_GAMEPAD_ENUM_END; -} - -// Events -void ska_input_register_gamepad_added_event(SkaInputDeviceIndex deviceIndex) {} - -void ska_input_register_gamepad_removed_event(SkaInputDeviceIndex deviceIndex) { - ska_input_reset_gamepad(deviceIndex); -} - -void ska_input_register_input_event3(SkaInputSourceType sourceType, SkaInputKey key, SkaInputTriggerType triggerType) { - ska_input_register_input_event2(sourceType, key, triggerType, SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX); -} - -void ska_input_register_input_event2(SkaInputSourceType sourceType, SkaInputKey key, SkaInputTriggerType triggerType, SkaInputDeviceIndex deviceIndex) { - ska_input_register_input_event(sourceType, key, triggerType, deviceIndex, 0.0f); -} - -void ska_input_register_input_event(SkaInputSourceType sourceType, SkaInputKey key, SkaInputTriggerType triggerType, SkaInputDeviceIndex deviceIndex, f32 gamepadAxisValue) { - SkaInputInteractionStatus interactionStatus = SkaInputInteractionStatus_PRESSED; - SkaInputKeyState* keyState = &inputState.inputKeyState[deviceIndex][key]; - - switch (triggerType) { - case SkaInputTriggerType_PRESSED: { - if (!keyState->isPressed) { - interactionStatus = SkaInputInteractionStatus_JUST_PRESSED; - keyState->isJustPressed = true; - SKA_ASSERT(inputState.cleanupKeyStateJustPressedCount + 1 <= SKA_INPUT_MAX_KEY_STATE_CLEANUP_SIZE); - inputState.cleanupKeyStateJustPressed[inputState.cleanupKeyStateJustPressedCount++] = (SkaInputStateCleanup) { .key = key, .deviceIndex = deviceIndex }; - } else { - keyState->isJustPressed = false; - } - keyState->isPressed = true; - keyState->isJustReleased = false; - keyState->strength = 1.0f; - break; - } - case SkaInputTriggerType_RELEASED: { - if (keyState->isJustReleased) { - return; - } - keyState->isPressed = false; - keyState->isJustPressed = false; - keyState->isJustReleased = true; - keyState->strength = 0.0f; - interactionStatus = SkaInputInteractionStatus_JUST_RELEASED; - SKA_ASSERT(inputState.cleanupKeyStateJustReleasedCount + 1 <= SKA_INPUT_MAX_KEY_STATE_CLEANUP_SIZE); - inputState.cleanupKeyStateJustReleased[inputState.cleanupKeyStateJustReleasedCount++] = (SkaInputStateCleanup) { .key = key, .deviceIndex = deviceIndex }; - break; - } - case SkaInputTriggerType_AXIS_IN_MOTION: { - if (!keyState->isPressed) { - interactionStatus = SkaInputInteractionStatus_AXIS_STARTED_MOTION; - keyState->isJustPressed = true; - SKA_ASSERT(inputState.cleanupKeyStateJustPressedCount + 1 <= SKA_INPUT_MAX_KEY_STATE_CLEANUP_SIZE); - inputState.cleanupKeyStateJustPressed[inputState.cleanupKeyStateJustPressedCount++] = (SkaInputStateCleanup) { .key = key, .deviceIndex = deviceIndex }; - } else { - interactionStatus = SkaInputInteractionStatus_AXIS_IN_MOTION; - keyState->isJustPressed = false; - } - keyState->isPressed = true; - keyState->isJustReleased = false; - keyState->strength = gamepadAxisValue; - - if (key != SkaInputKey_GAMEPAD_LEFT_TRIGGER && key != SkaInputKey_GAMEPAD_RIGHT_TRIGGER) { - update_axis_key_state(key, interactionStatus, gamepadAxisValue, deviceIndex); - } - break; - } - case SkaInputTriggerType_AXIS_STOPPED_MOTION: { - if (keyState->isJustReleased) { - return; - } - interactionStatus = SkaInputInteractionStatus_AXIS_STOPPED_MOTION; - keyState->isPressed = false; - keyState->isJustPressed = false; - keyState->isJustReleased = true; - keyState->strength = 0.0f; - SKA_ASSERT(inputState.cleanupKeyStateJustReleasedCount + 1 <= SKA_INPUT_MAX_KEY_STATE_CLEANUP_SIZE); - inputState.cleanupKeyStateJustReleased[inputState.cleanupKeyStateJustReleasedCount++] = (SkaInputStateCleanup) { .key = key, .deviceIndex = deviceIndex }; - - if (key != SkaInputKey_GAMEPAD_LEFT_TRIGGER && key != SkaInputKey_GAMEPAD_RIGHT_TRIGGER) { - update_axis_key_state(key, interactionStatus, gamepadAxisValue, deviceIndex); - } - break; - } - case SkaInputTriggerType_DEVICE_ADDED: - case SkaInputTriggerType_DEVICE_REMOVED: - case SkaInputTriggerType_INVALID: - break; - } - -// const SkaInputEvent inputEvent = (SkaInputEvent) { .sourceType = sourceType, .interactionStatus = interactionStatus, .key = key, .deviceIndex = deviceIndex, gamepadAxisValue = gamepadAxisValue }; -} - -bool ska_input_is_key_pressed(SkaInputKey key, SkaInputDeviceIndex deviceIndex) { - return inputState.inputKeyState[deviceIndex][key].isPressed; -} -bool ska_input_is_key_just_pressed(SkaInputKey key, SkaInputDeviceIndex deviceIndex) { - return inputState.inputKeyState[deviceIndex][key].isJustPressed; -} -bool ska_input_is_key_just_released(SkaInputKey key, SkaInputDeviceIndex deviceIndex) { - return inputState.inputKeyState[deviceIndex][key].isJustReleased; -} -f32 ska_input_get_key_strength(SkaInputKey key, SkaInputDeviceIndex deviceIndex) { - return inputState.inputKeyState[deviceIndex][key].strength; -} - -SkaVector2 ska_input_get_axis_input(SkaInputAxis axis, SkaInputDeviceIndex deviceIndex) { - struct SkaAxis2DInputKeys { - SkaInputKey x; - SkaInputKey y; - }; - - const struct SkaAxis2DInputKeys axisKeys = axis == SkaInputAxis_LEFT - ? (struct SkaAxis2DInputKeys) { .x = SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X, .y = SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y } - : (struct SkaAxis2DInputKeys) { .x = SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X, .y = SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_Y }; - const SkaInputKeyState* xKeyState = &inputState.inputKeyState[deviceIndex][axisKeys.x]; - const SkaInputKeyState* yKeyState = &inputState.inputKeyState[deviceIndex][axisKeys.y]; - return (SkaVector2) { .x = xKeyState->strength, .y = yKeyState->strength }; -} - -SkaMouse* ska_input_get_mouse() { - return &globalMouse; -} - -// Input Action -SkaInputActionHandle ska_input_add_input_action(const char* actionName, const SkaInputActionValue* actionValues, SkaInputDeviceIndex deviceIndex) { - SkaInputActionHandle actionHandle = ska_input_find_input_action_handle(actionName, deviceIndex); - if (actionHandle == SKA_INPUT_INVALID_INPUT_ACTION_HANDLE) { - SKA_ASSERT(inputState.inputActionHandleIndex + 1 < SKA_INPUT_MAX_INPUT_ACTIONS); - actionHandle = inputState.inputActionHandleIndex++; - SkaInputActionData* actionData = &inputState.inputActionData[deviceIndex][actionHandle]; - actionData->handle = actionHandle; - actionData->action.name = ska_strdup(actionName); - actionData->action.actionValuesCount = 0; - } - - SkaInputActionData* actionData = &inputState.inputActionData[deviceIndex][actionHandle]; - for (usize i = 0; i < SKA_INPUT_MAX_INPUT_ACTION_VALUES; i++) { - if (!actionValues[i].key) { - break; - } - SKA_ASSERT(actionData->action.actionValuesCount + 1 < SKA_INPUT_MAX_INPUT_ACTION_VALUES); - actionData->action.actionValues[actionData->action.actionValuesCount++] = actionValues[i]; - } - return actionHandle; -} - -SkaInputAction* ska_input_get_input_action(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex) { - SkaInputActionData* actionData = &inputState.inputActionData[deviceIndex][handle]; - if (actionData->handle) { - return &actionData->action; - } - return NULL; -} - -bool ska_input_remove_input_action(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex) { - SkaInputActionData* actionData = &inputState.inputActionData[deviceIndex][handle]; - if (actionData->handle != SKA_INPUT_INVALID_INPUT_ACTION_HANDLE) { - SKA_MEM_FREE(actionData->action.name); - actionData->action.name = NULL; - actionData->handle = SKA_INPUT_INVALID_INPUT_ACTION_HANDLE; - return true; - } - return false; -} - -SkaInputActionHandle ska_input_find_input_action_handle(const char* actionName, SkaInputDeviceIndex deviceIndex) { - for (SkaInputActionHandle handle = 0; handle < SKA_INPUT_MAX_INPUT_ACTIONS; handle++) { - SkaInputActionData* actionData = &inputState.inputActionData[deviceIndex][handle]; - // TODO: Shouldn't have to check for NULL name as handle should be enough - if (actionData->handle == SKA_INPUT_INVALID_INPUT_ACTION_HANDLE || actionData->action.name == NULL) { - continue; - } - if (strcmp(actionData->action.name, actionName) == 0) { - return actionData->handle; - } - } - return SKA_INPUT_INVALID_INPUT_ACTION_HANDLE; -} - -bool ska_input_is_input_action_pressed(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex) { - const SkaInputActionData* actionData = &inputState.inputActionData[deviceIndex][handle]; - for (usize i = 0; i < actionData->action.actionValuesCount; i++) { - const SkaInputActionValue* actionValue = &actionData->action.actionValues[i]; - if (ska_input_is_key_pressed(actionValue->key, deviceIndex)) { - return true; - } - } - return false; -} - -bool ska_input_is_input_action_just_pressed(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex) { - const SkaInputActionData* actionData = &inputState.inputActionData[deviceIndex][handle]; - for (usize i = 0; i < actionData->action.actionValuesCount; i++) { - const SkaInputActionValue* actionValue = &actionData->action.actionValues[i]; - if (ska_input_is_key_just_pressed(actionValue->key, deviceIndex)) { - return true; - } - } - return false; -} - -bool ska_input_is_input_action_just_released(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex) { - const SkaInputActionData* actionData = &inputState.inputActionData[deviceIndex][handle]; - for (usize i = 0; i < actionData->action.actionValuesCount; i++) { - const SkaInputActionValue* actionValue = &actionData->action.actionValues[i]; - if (ska_input_is_key_just_released(actionValue->key, deviceIndex)) { - return true; - } - } - return false; -} - -f32 ska_input_get_input_action_strength(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex) { - const SkaInputActionData* actionData = &inputState.inputActionData[deviceIndex][handle]; - for (usize i = 0; i < actionData->action.actionValuesCount; i++) { - const SkaInputActionValue* actionValue = &actionData->action.actionValues[i]; - const f32 keyStrength = ska_input_get_key_strength(actionValue->key, deviceIndex); - if (keyStrength >= actionValue->strengthThreshold) { - return keyStrength; - } - } - return 0.0f; -} - -void ska_input_new_frame() { - for (usize i = 0; i < inputState.cleanupKeyStateJustPressedCount; i++) { - const SkaInputStateCleanup* stateCleanup = &inputState.cleanupKeyStateJustPressed[i]; - SkaInputKeyState* keyState = &inputState.inputKeyState[stateCleanup->deviceIndex][stateCleanup->key]; - keyState->isJustPressed = false; - } - for (usize i = 0; i < inputState.cleanupKeyStateJustReleasedCount; i++) { - const SkaInputStateCleanup* stateCleanup = &inputState.cleanupKeyStateJustReleased[i]; - SkaInputKeyState* keyState = &inputState.inputKeyState[stateCleanup->deviceIndex][stateCleanup->key]; - keyState->isJustReleased = false; - } - inputState.cleanupKeyStateJustPressedCount = 0; - inputState.cleanupKeyStateJustReleasedCount = 0; -} - -void ska_input_reset_gamepad(SkaInputDeviceIndex deviceIndex) { - SKA_INPUT_KEY_GAMEPAD_FOR_EACH(key) { - inputState.inputKeyState[deviceIndex][key] = (SkaInputKeyState){0}; - } -} - -void ska_input_reset(SkaInputDeviceIndex deviceIndex) { - inputState = (SkaInputState)DEFAULT_INPUT_STATE; -} - -// Private -SkaInputKey get_key_from_2d_axis_key(SkaInputKey axis2DKey, SkaAxisInputValues* axisInputValues, f32 axisValue) { - switch (axis2DKey) { - case SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X: { - const f32 activeValue = axisInputValues->left.x != 0.0f ? axisInputValues->left.x : axisValue; - return activeValue > 0 ? SkaInputKey_GAMEPAD_LEFT_ANALOG_RIGHT : SkaInputKey_GAMEPAD_LEFT_ANALOG_LEFT; - } - case SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y: { - const f32 activeValue = axisInputValues->left.y != 0.0f ? axisInputValues->left.y : axisValue; - return activeValue > 0 ? SkaInputKey_GAMEPAD_LEFT_ANALOG_DOWN : SkaInputKey_GAMEPAD_LEFT_ANALOG_UP; - } - case SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X: { - const f32 activeValue = axisInputValues->right.x != 0.0f ? axisInputValues->right.x : axisValue; - return activeValue > 0 ? SkaInputKey_GAMEPAD_RIGHT_ANALOG_RIGHT : SkaInputKey_GAMEPAD_RIGHT_ANALOG_LEFT; - } - case SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_Y: { - const f32 activeValue = axisInputValues->right.y != 0.0f ? axisInputValues->right.y : axisValue; - return activeValue > 0 ? SkaInputKey_GAMEPAD_RIGHT_ANALOG_DOWN : SkaInputKey_GAMEPAD_RIGHT_ANALOG_UP; - } - default: { - SKA_ASSERT_FMT(false, "Not a valid axis input key!"); - return SkaInputKey_INVALID; - } - } -} - -void set_prev_input_axis_value(SkaInputKey key, SkaAxisInputValues* axisInputValues, f32 axisValue) { - switch (key) { - case SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X: { - axisInputValues->left.x = axisValue; - break; - } - case SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y: { - axisInputValues->left.y = axisValue; - break; - } - case SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X: { - axisInputValues->right.x = axisValue; - break; - } - case SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_Y: { - axisInputValues->right.y = axisValue; - break; - } - default: { - SKA_ASSERT_FMT(false, "Not a valid axis input key!"); - } - } -} - -void update_axis_key_state(SkaInputKey key, SkaInputInteractionStatus interactionStatus, f32 axisValue, SkaInputDeviceIndex deviceIndex) { - SkaAxisInputValues* prevAxisInput = &inputState.prevAxisInputs[deviceIndex]; - const SkaInputKey axisKey = get_key_from_2d_axis_key(key, prevAxisInput, axisValue); - SkaInputKeyState* axisKeyState = &inputState.inputKeyState[deviceIndex][axisKey]; - switch (interactionStatus) { - case SkaInputInteractionStatus_AXIS_STARTED_MOTION: - case SkaInputInteractionStatus_AXIS_IN_MOTION: { - axisKeyState->isPressed = true; - if (interactionStatus == SkaInputInteractionStatus_AXIS_STARTED_MOTION) { - axisKeyState->isJustPressed = true; - SKA_ASSERT(inputState.cleanupKeyStateJustPressedCount + 1 <= SKA_INPUT_MAX_KEY_STATE_CLEANUP_SIZE); - inputState.cleanupKeyStateJustPressed[inputState.cleanupKeyStateJustPressedCount++] = (SkaInputStateCleanup) { .key = key, .deviceIndex = deviceIndex }; - } else { - axisKeyState->isJustPressed = false; - } - axisKeyState->isJustReleased = false; - axisKeyState->strength = (f32)fabs(axisValue); - set_prev_input_axis_value(key, prevAxisInput, axisValue); - break; - } - case SkaInputInteractionStatus_AXIS_STOPPED_MOTION: { - axisKeyState->isPressed = false; - axisKeyState->isJustPressed = false; - axisKeyState->isJustReleased = true; - axisKeyState->strength = 0.0f; - set_prev_input_axis_value(key, prevAxisInput, 0.0f); - SKA_ASSERT(inputState.cleanupKeyStateJustReleasedCount + 1 <= SKA_INPUT_MAX_KEY_STATE_CLEANUP_SIZE); - inputState.cleanupKeyStateJustReleased[inputState.cleanupKeyStateJustReleasedCount++] = (SkaInputStateCleanup) { .key = key, .deviceIndex = deviceIndex }; - break; - } - default: { - SKA_ASSERT_FMT(false, "Invalid interaction status fo 2d axis key when trying to update key state!"); - } - } -} diff --git a/old_seika/input/input.h b/old_seika/input/input.h deleted file mode 100644 index b293b10..0000000 --- a/old_seika/input/input.h +++ /dev/null @@ -1,292 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -#include "seika/math/math.h" - -typedef int32 SkaInputDeviceIndex; -typedef uint32 SkaInputSubscriberHandle; -typedef uint32 SkaInputActionHandle; -typedef float SkaInputKeyStrength; - -#define SKA_INPUT_MAX_DEVICES ((SkaInputDeviceIndex)8) -#define SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX ((SkaInputDeviceIndex)0) -#define SKA_INPUT_MAX_INPUT_ACTIONS ((SkaInputActionHandle)128) -#define SKA_INPUT_INVALID_INPUT_ACTION_HANDLE ((SkaInputActionHandle)-1) -#define SKA_INPUT_MAX_INPUT_ACTION_VALUES 8 - -typedef enum SkaInputSourceType { - SkaInputSourceType_INVALID, - SkaInputSourceType_KEYBOARD, - SkaInputSourceType_GAMEPAD, - SkaInputSourceType_MOUSE, -} SkaInputSourceType; - -typedef enum SkaInputTriggerType { - SkaInputTriggerType_INVALID, - SkaInputTriggerType_PRESSED, - SkaInputTriggerType_RELEASED, - SkaInputTriggerType_AXIS_IN_MOTION, - SkaInputTriggerType_AXIS_STOPPED_MOTION, - SkaInputTriggerType_DEVICE_ADDED, - SkaInputTriggerType_DEVICE_REMOVED, -} SkaInputTriggerType; - -typedef enum SkaInputInteractionStatus { - SkaInputInteractionStatus_PRESSED, - SkaInputInteractionStatus_JUST_PRESSED, - SkaInputInteractionStatus_JUST_RELEASED, - SkaInputInteractionStatus_AXIS_STARTED_MOTION, - SkaInputInteractionStatus_AXIS_IN_MOTION, - SkaInputInteractionStatus_AXIS_STOPPED_MOTION, -} SkaInputInteractionStatus; - -typedef enum SkaInputKey { - SkaInputKey_INVALID, - // Gamepad - SkaInputKey_GAMEPAD_DPAD_DOWN, - SkaInputKey_GAMEPAD_DPAD_UP, - SkaInputKey_GAMEPAD_DPAD_LEFT, - SkaInputKey_GAMEPAD_DPAD_RIGHT, - SkaInputKey_GAMEPAD_FACE_BUTTON_NORTH, // XBOX Y - SkaInputKey_GAMEPAD_FACE_BUTTON_SOUTH, // XBOX A - SkaInputKey_GAMEPAD_FACE_BUTTON_EAST, // XBOX B - SkaInputKey_GAMEPAD_FACE_BUTTON_WEST, // XBOX X - SkaInputKey_GAMEPAD_START, - SkaInputKey_GAMEPAD_BACK, - SkaInputKey_GAMEPAD_LEFT_SHOULDER, // PS L1 - SkaInputKey_GAMEPAD_LEFT_TRIGGER, // PS L2 - SkaInputKey_GAMEPAD_LEFT_ANALOG_BUTTON, // PS L3 - SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X, - SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y, - SkaInputKey_GAMEPAD_RIGHT_SHOULDER, // PS R1 - SkaInputKey_GAMEPAD_RIGHT_TRIGGER, // PS R2 - SkaInputKey_GAMEPAD_RIGHT_ANALOG_BUTTON, // PS R3 - SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X, - SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_Y, - // Keeping these separate as 'RegisterInputEvent' should only use 'SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X', 'SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y', - // 'SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X', and 'SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_Y'. - // The key states for these keys will be updated automatically by the input system. - SkaInputKey_GAMEPAD_LEFT_ANALOG_LEFT, - SkaInputKey_GAMEPAD_LEFT_ANALOG_RIGHT, - SkaInputKey_GAMEPAD_LEFT_ANALOG_UP, - SkaInputKey_GAMEPAD_LEFT_ANALOG_DOWN, - SkaInputKey_GAMEPAD_RIGHT_ANALOG_LEFT, - SkaInputKey_GAMEPAD_RIGHT_ANALOG_RIGHT, - SkaInputKey_GAMEPAD_RIGHT_ANALOG_UP, - SkaInputKey_GAMEPAD_RIGHT_ANALOG_DOWN, - - // Keyboard - SkaInputKey_KEYBOARD_TAB, - SkaInputKey_KEYBOARD_LEFT, - SkaInputKey_KEYBOARD_RIGHT, - SkaInputKey_KEYBOARD_UP, - SkaInputKey_KEYBOARD_DOWN, - SkaInputKey_KEYBOARD_PAGE_DOWN, - SkaInputKey_KEYBOARD_PAGE_UP, - SkaInputKey_KEYBOARD_HOME, - SkaInputKey_KEYBOARD_END, - SkaInputKey_KEYBOARD_INSERT, - SkaInputKey_KEYBOARD_DELETE, - SkaInputKey_KEYBOARD_BACKSPACE, - SkaInputKey_KEYBOARD_SPACE, - SkaInputKey_KEYBOARD_RETURN, - SkaInputKey_KEYBOARD_ESCAPE, - SkaInputKey_KEYBOARD_QUOTE, - SkaInputKey_KEYBOARD_COMMA, - SkaInputKey_KEYBOARD_MINUS, - SkaInputKey_KEYBOARD_PERIOD, - SkaInputKey_KEYBOARD_SLASH, - SkaInputKey_KEYBOARD_SEMICOLON, - SkaInputKey_KEYBOARD_EQUALS, - SkaInputKey_KEYBOARD_LEFT_BRACKET, - SkaInputKey_KEYBOARD_RIGHT_BRACKET, - SkaInputKey_KEYBOARD_BACKSLASH, - SkaInputKey_KEYBOARD_BACKQUOTE, - SkaInputKey_KEYBOARD_CAPS_LOCK, - SkaInputKey_KEYBOARD_SCROLL_LOCK, - SkaInputKey_KEYBOARD_NUM_LOCK_CLEAR, - SkaInputKey_KEYBOARD_PRINT_SCREEN, - SkaInputKey_KEYBOARD_PAUSE, - SkaInputKey_KEYBOARD_KEYPAD_0, - SkaInputKey_KEYBOARD_KEYPAD_1, - SkaInputKey_KEYBOARD_KEYPAD_2, - SkaInputKey_KEYBOARD_KEYPAD_3, - SkaInputKey_KEYBOARD_KEYPAD_4, - SkaInputKey_KEYBOARD_KEYPAD_5, - SkaInputKey_KEYBOARD_KEYPAD_6, - SkaInputKey_KEYBOARD_KEYPAD_7, - SkaInputKey_KEYBOARD_KEYPAD_8, - SkaInputKey_KEYBOARD_KEYPAD_9, - SkaInputKey_KEYBOARD_KEYPAD_PERIOD, - SkaInputKey_KEYBOARD_KEYPAD_DIVIDE, - SkaInputKey_KEYBOARD_KEYPAD_MULTIPLY, - SkaInputKey_KEYBOARD_KEYPAD_MINUS, - SkaInputKey_KEYBOARD_KEYPAD_PLUS, - SkaInputKey_KEYBOARD_KEYPAD_ENTER, - SkaInputKey_KEYBOARD_KEYPAD_EQUALS, - SkaInputKey_KEYBOARD_LEFT_CONTROL, - SkaInputKey_KEYBOARD_LEFT_SHIFT, - SkaInputKey_KEYBOARD_LEFT_ALT, - SkaInputKey_KEYBOARD_LEFT_GUI, - SkaInputKey_KEYBOARD_RIGHT_CONTROL, - SkaInputKey_KEYBOARD_RIGHT_SHIFT, - SkaInputKey_KEYBOARD_RIGHT_ALT, - SkaInputKey_KEYBOARD_RIGHT_GUI, - SkaInputKey_KEYBOARD_APPLICATION, - SkaInputKey_KEYBOARD_NUM_0, - SkaInputKey_KEYBOARD_NUM_1, - SkaInputKey_KEYBOARD_NUM_2, - SkaInputKey_KEYBOARD_NUM_3, - SkaInputKey_KEYBOARD_NUM_4, - SkaInputKey_KEYBOARD_NUM_5, - SkaInputKey_KEYBOARD_NUM_6, - SkaInputKey_KEYBOARD_NUM_7, - SkaInputKey_KEYBOARD_NUM_8, - SkaInputKey_KEYBOARD_NUM_9, - SkaInputKey_KEYBOARD_A, - SkaInputKey_KEYBOARD_B, - SkaInputKey_KEYBOARD_C, - SkaInputKey_KEYBOARD_D, - SkaInputKey_KEYBOARD_E, - SkaInputKey_KEYBOARD_F, - SkaInputKey_KEYBOARD_G, - SkaInputKey_KEYBOARD_H, - SkaInputKey_KEYBOARD_I, - SkaInputKey_KEYBOARD_J, - SkaInputKey_KEYBOARD_K, - SkaInputKey_KEYBOARD_L, - SkaInputKey_KEYBOARD_M, - SkaInputKey_KEYBOARD_N, - SkaInputKey_KEYBOARD_O, - SkaInputKey_KEYBOARD_P, - SkaInputKey_KEYBOARD_Q, - SkaInputKey_KEYBOARD_R, - SkaInputKey_KEYBOARD_S, - SkaInputKey_KEYBOARD_T, - SkaInputKey_KEYBOARD_U, - SkaInputKey_KEYBOARD_V, - SkaInputKey_KEYBOARD_W, - SkaInputKey_KEYBOARD_X, - SkaInputKey_KEYBOARD_Y, - SkaInputKey_KEYBOARD_Z, - SkaInputKey_KEYBOARD_F1, - SkaInputKey_KEYBOARD_F2, - SkaInputKey_KEYBOARD_F3, - SkaInputKey_KEYBOARD_F4, - SkaInputKey_KEYBOARD_F5, - SkaInputKey_KEYBOARD_F6, - SkaInputKey_KEYBOARD_F7, - SkaInputKey_KEYBOARD_F8, - SkaInputKey_KEYBOARD_F9, - SkaInputKey_KEYBOARD_F10, - SkaInputKey_KEYBOARD_F11, - SkaInputKey_KEYBOARD_F12, - SkaInputKey_KEYBOARD_F13, - SkaInputKey_KEYBOARD_F14, - SkaInputKey_KEYBOARD_F15, - SkaInputKey_KEYBOARD_F16, - SkaInputKey_KEYBOARD_F17, - SkaInputKey_KEYBOARD_F18, - SkaInputKey_KEYBOARD_F19, - SkaInputKey_KEYBOARD_F20, - SkaInputKey_KEYBOARD_F21, - SkaInputKey_KEYBOARD_F22, - SkaInputKey_KEYBOARD_F23, - SkaInputKey_KEYBOARD_F24, - SkaInputKey_KEYBOARD_APP_FORWARD, - SkaInputKey_KEYBOARD_APP_BACK, - - // Mouse - SkaInputKey_MOUSE_BUTTON_LEFT, - SkaInputKey_MOUSE_BUTTON_RIGHT, - SkaInputKey_MOUSE_BUTTON_MIDDLE, - - SkaInputKey_NUMBER_OF_KEYS -} SkaInputKey; - -#define SKA_INPUT_KEY_GAMEPAD_ENUM_START SkaInputKey_GAMEPAD_DPAD_DOWN -#define SKA_INPUT_KEY_GAMEPAD_ENUM_END SkaInputKey_GAMEPAD_RIGHT_ANALOG_DOWN -#define SKA_INPUT_KEY_KEYBOARD_ENUM_START SkaInputKey_KEYBOARD_TAB -#define SKA_INPUT_KEY_KEYBOARD_ENUM_END SkaInputKey_KEYBOARD_APP_BACK -#define SKA_INPUT_KEY_MOUSE_ENUM_START SkaInputKey_MOUSE_BUTTON_LEFT -#define SKA_INPUT_KEY_MOUSE_ENUM_END SkaInputKey_MOUSE_BUTTON_MIDDLE - -#define SKA_INPUT_KEY_GAMEPAD_COUNT (SKA_INPUT_KEY_GAMEPAD_ENUM_END - SKA_INPUT_KEY_GAMEPAD_ENUM_START) -#define SKA_INPUT_KEY_KEYBOARD_COUNT (SKA_INPUT_KEY_KEYBOARD_ENUM_END - SKA_INPUT_KEY_KEYBOARD_ENUM_START) -#define SKA_INPUT_KEY_MOUSE_COUNT (SKA_INPUT_KEY_MOUSE_ENUM_END - SKA_INPUT_KEY_MOUSE_ENUM_START) - -#define SKA_INPUT_KEY_GAMEPAD_FOR_EACH(KeyName) for(SkaInputKey KeyName = SKA_INPUT_KEY_GAMEPAD_ENUM_START; KeyName <= SKA_INPUT_KEY_GAMEPAD_ENUM_END; KeyName++) -#define SKA_INPUT_KEY_KEYBOARD_FOR_EACH(KeyName) for(SkaInputKey KeyName = SKA_INPUT_KEY_KEYBOARD_ENUM_START; KeyName <= SKA_INPUT_KEY_KEYBOARD_ENUM_END; KeyName++) -#define SKA_INPUT_KEY_MOUSE_FOR_EACH(KeyName) for(SkaInputKey KeyName = SKA_INPUT_KEY_MOUSE_ENUM_START; KeyName <= SKA_INPUT_KEY_MOUSE_ENUM_END; KeyName++) - -typedef enum SkaInputAxis { - SkaInputAxis_LEFT, - SkaInputAxis_RIGHT, -} SkaInputAxis; - -typedef struct SkaMouse { - SkaVector2 position; -} SkaMouse; - -typedef struct SkaInputEvent { - SkaInputSourceType sourceType; - SkaInputInteractionStatus interactionStatus; - SkaInputKey key; - SkaInputDeviceIndex deviceIndex; - f32 gamepadAxisValue; -} SkaInputEvent; - -typedef struct SkaInputActionValue { - SkaInputKey key; - SkaInputKeyStrength strengthThreshold; -} SkaInputActionValue; - -typedef struct SkaInputAction { - char* name; - SkaInputActionValue actionValues[SKA_INPUT_MAX_INPUT_ACTION_VALUES]; - usize actionValuesCount; -} SkaInputAction; - -const char* ska_input_key_to_string(SkaInputKey key); -SkaInputKey ska_input_string_to_key(const char* keyName); - -bool ska_input_is_keyboard_key(SkaInputKey key); -bool ska_input_is_mouse_key(SkaInputKey key); -bool ska_input_is_gamepad_key(SkaInputKey key); - -// Events -void ska_input_register_gamepad_added_event(SkaInputDeviceIndex deviceIndex); -void ska_input_register_gamepad_removed_event(SkaInputDeviceIndex deviceIndex); -void ska_input_register_input_event(SkaInputSourceType sourceType, SkaInputKey key, SkaInputTriggerType triggerType, SkaInputDeviceIndex deviceIndex, f32 gamepadAxisValue); -void ska_input_register_input_event2(SkaInputSourceType sourceType, SkaInputKey key, SkaInputTriggerType triggerType, SkaInputDeviceIndex deviceIndex); -void ska_input_register_input_event3(SkaInputSourceType sourceType, SkaInputKey key, SkaInputTriggerType triggerType); - -bool ska_input_is_key_pressed(SkaInputKey key, SkaInputDeviceIndex deviceIndex); -bool ska_input_is_key_just_pressed(SkaInputKey key, SkaInputDeviceIndex deviceIndex); -bool ska_input_is_key_just_released(SkaInputKey key, SkaInputDeviceIndex deviceIndex); -f32 ska_input_get_key_strength(SkaInputKey key, SkaInputDeviceIndex deviceIndex); -SkaVector2 ska_input_get_axis_input(SkaInputAxis axis, SkaInputDeviceIndex deviceIndex); - -SkaMouse* ska_input_get_mouse(); - -// Input Action -SkaInputActionHandle ska_input_add_input_action(const char* actionName, const SkaInputActionValue* actionValues, SkaInputDeviceIndex deviceIndex); -SkaInputAction* ska_input_get_input_action(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex); -bool ska_input_remove_input_action(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex); -SkaInputActionHandle ska_input_find_input_action_handle(const char* actionName, SkaInputDeviceIndex deviceIndex); - -bool ska_input_is_input_action_pressed(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex); -bool ska_input_is_input_action_just_pressed(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex); -bool ska_input_is_input_action_just_released(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex); -f32 ska_input_get_input_action_strength(SkaInputActionHandle handle, SkaInputDeviceIndex deviceIndex); - -void ska_input_new_frame(); -void ska_input_reset_gamepad(SkaInputDeviceIndex deviceIndex); -void ska_input_reset(SkaInputDeviceIndex deviceIndex); - -#ifdef __cplusplus -} -#endif diff --git a/old_seika/input/sdl_gamepad_db.h b/old_seika/input/sdl_gamepad_db.h deleted file mode 100644 index 1b09484..0000000 --- a/old_seika/input/sdl_gamepad_db.h +++ /dev/null @@ -1,41987 +0,0 @@ -#pragma once - -const unsigned char SKA_GAMEPAD_DB_HEX[] = { - 0x23, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x44, 0x42, 0x20, 0x66, 0x6f, 0x72, - 0x20, 0x53, 0x44, 0x4c, 0x20, 0x69, 0x6e, 0x20, 0x32, 0x2e, 0x30, 0x2e, - 0x31, 0x36, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x0d, 0x0a, 0x23, - 0x20, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x3a, 0x20, 0x68, 0x74, 0x74, - 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, - 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x61, 0x62, 0x6f, 0x6d, 0x64, 0x71, 0x2f, - 0x53, 0x44, 0x4c, 0x5f, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x44, 0x42, 0x0d, 0x0a, 0x0d, 0x0a, - 0x23, 0x20, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x33, 0x20, 0x49, 0x6e, - 0x20, 0x31, 0x20, 0x43, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, - 0x6e, 0x20, 0x42, 0x6f, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x61, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x33, 0x64, 0x52, - 0x75, 0x64, 0x64, 0x65, 0x72, 0x20, 0x46, 0x6f, 0x6f, 0x74, 0x20, 0x4d, - 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, - 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x64, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x34, - 0x50, 0x6c, 0x61, 0x79, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, - 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x34, 0x50, 0x6c, 0x61, 0x79, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x64, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x34, 0x50, 0x6c, 0x61, 0x79, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x33, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, - 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x34, 0x50, 0x6c, 0x61, 0x79, 0x20, 0x41, 0x64, 0x61, 0x70, - 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x64, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, - 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x34, 0x50, 0x6c, 0x61, 0x79, 0x20, 0x41, 0x64, 0x61, - 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20, - 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x39, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x44, - 0x6f, 0x67, 0x62, 0x6f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, - 0x46, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x31, 0x61, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x46, - 0x33, 0x30, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, - 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, - 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, - 0x69, 0x74, 0x44, 0x6f, 0x20, 0x46, 0x33, 0x30, 0x20, 0x41, 0x72, 0x63, - 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, - 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x61, 0x62, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, - 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x46, 0x33, 0x30, 0x20, 0x41, 0x72, - 0x63, 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x46, - 0x33, 0x30, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, 0x74, - 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x46, - 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x46, 0x43, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, - 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, - 0x74, 0x65, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x31, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, - 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x53, 0x45, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, - 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, - 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, - 0x64, 0x30, 0x30, 0x30, 0x30, 0x35, 0x31, 0x30, 0x36, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, - 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, - 0x61, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x32, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, - 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, - 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, - 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x20, - 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x36, 0x35, 0x32, 0x38, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x20, - 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, - 0x44, 0x6f, 0x20, 0x4e, 0x36, 0x34, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x62, 0x39, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x62, 0x34, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x62, 0x38, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x36, 0x34, 0x2c, 0x2b, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x62, 0x39, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x62, 0x38, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x35, 0x31, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x61, 0x62, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, - 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, 0x53, 0x33, 0x30, 0x2c, 0x61, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x32, 0x61, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, - 0x44, 0x6f, 0x20, 0x4e, 0x45, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x4e, 0x45, 0x53, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, - 0x4e, 0x45, 0x53, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, - 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, - 0x53, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, - 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x35, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, - 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x50, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, - 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, - 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, - 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, - 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x33, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, - 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, - 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, - 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x38, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, - 0x44, 0x6f, 0x20, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, - 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, - 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, 0x33, 0x30, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, - 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, 0x33, 0x30, 0x20, - 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, - 0x43, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, - 0x61, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, - 0x43, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, - 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, - 0x43, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, - 0x61, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, - 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, - 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, - 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x39, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, - 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, - 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x61, 0x62, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x32, - 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, - 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x36, - 0x32, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, - 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, - 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, - 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, - 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, - 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, - 0x50, 0x72, 0x6f, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, - 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, - 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, - 0x72, 0x6f, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, - 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, - 0x69, 0x74, 0x44, 0x6f, 0x20, 0x55, 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x74, - 0x65, 0x20, 0x57, 0x69, 0x72, 0x65, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x32, 0x36, - 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x32, 0x34, - 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x32, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x55, 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, - 0x20, 0x57, 0x69, 0x72, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x55, 0x6c, 0x74, 0x69, - 0x6d, 0x61, 0x74, 0x65, 0x20, 0x57, 0x69, 0x72, 0x65, 0x6c, 0x65, 0x73, - 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, - 0x63, 0x31, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, - 0x65, 0x31, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, - 0x65, 0x32, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, - 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x32, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x32, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, - 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x41, 0x63, 0x6d, 0x65, 0x20, 0x47, 0x41, 0x30, 0x32, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x41, 0x63, 0x72, 0x75, 0x78, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, - 0x61, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, 0x66, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x41, 0x63, 0x74, 0x65, 0x63, 0x6b, 0x20, 0x41, 0x47, 0x4a, 0x20, 0x33, - 0x32, 0x30, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x31, 0x31, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x30, 0x32, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x44, 0x54, 0x31, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, - 0x61, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x30, 0x38, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, - 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x50, 0x53, 0x33, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, - 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x50, 0x53, - 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, - 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, - 0x77, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x34, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, - 0x6c, 0x6f, 0x77, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, - 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, - 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, - 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x50, 0x53, 0x33, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, - 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, - 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, - 0x6c, 0x6f, 0x77, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, - 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, - 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x33, 0x39, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x61, 0x62, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, - 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, - 0x6c, 0x6f, 0x77, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, - 0x6b, 0x69, 0x73, 0x68, 0x6f, 0x70, 0x20, 0x43, 0x75, 0x73, 0x74, 0x6f, - 0x6d, 0x73, 0x20, 0x50, 0x53, 0x33, 0x36, 0x30, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x63, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x41, 0x6c, 0x69, 0x65, 0x6e, 0x77, 0x61, 0x72, 0x65, - 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x74, - 0x69, 0x62, 0x6c, 0x65, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x39, 0x31, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x39, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x6d, 0x61, 0x7a, 0x6f, - 0x6e, 0x20, 0x4c, 0x75, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, - 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x41, 0x6d, 0x61, 0x7a, 0x6f, 0x6e, 0x20, 0x4c, 0x75, - 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, - 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x72, 0x6d, 0x6f, - 0x72, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x39, 0x30, 0x62, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x34, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x53, 0x43, 0x49, 0x49, - 0x20, 0x53, 0x65, 0x61, 0x6d, 0x69, 0x63, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x39, 0x38, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x73, 0x74, - 0x72, 0x6f, 0x20, 0x43, 0x34, 0x30, 0x20, 0x54, 0x52, 0x20, 0x50, 0x53, - 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x41, 0x73, 0x74, 0x72, 0x6f, 0x20, 0x43, 0x69, - 0x74, 0x79, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x73, 0x74, 0x72, 0x6f, 0x20, 0x43, - 0x69, 0x74, 0x79, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x53, 0x55, 0x53, 0x20, 0x52, 0x4f, - 0x47, 0x20, 0x4b, 0x75, 0x6e, 0x61, 0x69, 0x20, 0x33, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x37, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x41, 0x53, 0x55, 0x53, 0x20, 0x52, 0x4f, 0x47, 0x20, 0x4b, 0x75, - 0x6e, 0x61, 0x69, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, - 0x20, 0x56, 0x43, 0x53, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, 0x20, 0x56, 0x43, 0x53, - 0x20, 0x4d, 0x6f, 0x64, 0x65, 0x72, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x34, - 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x33, 0x66, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, - 0x61, 0x74, 0x61, 0x72, 0x61, 0x6e, 0x67, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x35, 0x35, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, - 0x61, 0x74, 0x61, 0x72, 0x61, 0x6e, 0x67, 0x20, 0x50, 0x6c, 0x61, 0x79, - 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x33, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x61, 0x74, 0x74, - 0x61, 0x6c, 0x69, 0x66, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x36, 0x2c, 0x62, 0x3a, 0x62, 0x37, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, - 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, - 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, - 0x61, 0x74, 0x74, 0x6c, 0x65, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x34, - 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x66, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x42, 0x20, 0x30, 0x37, 0x30, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x61, 0x37, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x42, 0x44, 0x41, 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x69, 0x67, - 0x68, 0x74, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x63, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, 0x69, 0x74, 0x6f, - 0x6e, 0x67, 0x20, 0x47, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, 0x6c, 0x6b, 0x69, - 0x6e, 0x20, 0x4e, 0x6f, 0x73, 0x74, 0x72, 0x6f, 0x6d, 0x6f, 0x20, 0x4e, - 0x34, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x62, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x42, 0x65, 0x74, 0x6f, 0x70, 0x20, 0x32, 0x31, 0x32, 0x36, 0x46, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x62, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, 0x74, 0x6f, 0x70, 0x20, 0x42, 0x46, - 0x4d, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x62, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x33, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, 0x74, 0x6f, 0x70, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x62, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x32, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x42, 0x65, 0x74, 0x6f, 0x70, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x63, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, 0x74, - 0x6f, 0x70, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, 0x74, 0x6f, 0x70, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x35, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x42, 0x65, 0x74, 0x6f, 0x70, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, 0x74, - 0x6f, 0x70, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x30, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x42, 0x65, 0x74, 0x6f, 0x70, 0x20, 0x47, 0x61, 0x6d, 0x65, - 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x46, 0x20, 0x4f, 0x6e, - 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, - 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, - 0x69, 0x67, 0x62, 0x65, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x69, 0x67, 0x62, 0x65, - 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x69, 0x67, 0x62, 0x65, 0x6e, 0x20, - 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x42, 0x69, 0x67, 0x62, 0x65, 0x6e, 0x20, 0x50, - 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, - 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x20, 0x4d, 0x61, 0x72, - 0x73, 0x20, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x72, 0x6f, 0x6f, - 0x6b, 0x20, 0x4d, 0x61, 0x72, 0x73, 0x20, 0x50, 0x53, 0x34, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, - 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x66, 0x31, 0x30, 0x65, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, - 0x72, 0x6f, 0x6f, 0x6b, 0x20, 0x50, 0x53, 0x32, 0x20, 0x41, 0x64, 0x61, - 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x72, 0x6f, - 0x6f, 0x6b, 0x20, 0x53, 0x75, 0x70, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x6e, - 0x76, 0x65, 0x72, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, 0x31, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x75, 0x66, - 0x66, 0x61, 0x6c, 0x6f, 0x20, 0x42, 0x53, 0x47, 0x50, 0x31, 0x36, 0x30, - 0x31, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x2c, 0x61, 0x3a, 0x62, - 0x35, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x62, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x43, 0x61, 0x70, 0x63, 0x6f, 0x6d, 0x20, 0x48, 0x6f, 0x6d, - 0x65, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x33, - 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x62, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x43, 0x61, 0x70, 0x63, 0x6f, 0x6d, 0x20, 0x48, - 0x6f, 0x6d, 0x65, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x32, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, 0x68, 0x69, 0x6c, 0x6c, 0x53, - 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, - 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x35, 0x38, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x43, 0x69, 0x64, 0x65, 0x6b, 0x6f, 0x20, 0x41, 0x4b, 0x30, 0x38, 0x62, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x35, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x43, 0x6f, 0x62, 0x72, 0x61, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x33, 0x33, 0x36, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, - 0x6f, 0x6d, 0x70, 0x65, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, - 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, - 0x35, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x43, 0x72, 0x6f, 0x6e, 0x75, 0x73, 0x4d, 0x61, - 0x78, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x64, 0x38, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x63, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x43, 0x74, 0x68, 0x75, 0x6c, 0x68, 0x75, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, - 0x38, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x63, 0x65, 0x66, 0x61, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x43, 0x74, 0x68, 0x75, 0x6c, 0x68, 0x75, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, - 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, - 0x79, 0x62, 0x65, 0x72, 0x20, 0x47, 0x61, 0x64, 0x67, 0x65, 0x74, 0x20, - 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x63, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, 0x79, 0x62, 0x6f, 0x72, - 0x67, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x32, 0x66, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, 0x79, 0x62, 0x6f, 0x72, 0x67, 0x20, - 0x56, 0x2e, 0x33, 0x20, 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x61, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x44, 0x41, 0x20, 0x4c, 0x65, 0x61, 0x64, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x37, 0x2c, 0x62, 0x3a, 0x62, 0x36, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x35, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x44, 0x61, 0x74, 0x65, 0x6c, 0x20, 0x41, - 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x35, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x44, 0x65, 0x66, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x47, 0x61, - 0x6d, 0x65, 0x20, 0x52, 0x61, 0x63, 0x65, 0x72, 0x20, 0x58, 0x37, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x39, 0x31, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x42, 0x6f, 0x78, 0x20, - 0x57, 0x69, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, - 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x65, 0x31, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x44, 0x75, 0x61, 0x6c, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x37, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x44, 0x75, 0x61, 0x6c, 0x20, - 0x50, 0x6f, 0x77, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x38, 0x2c, 0x62, - 0x3a, 0x62, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x62, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x44, 0x75, 0x61, - 0x6c, 0x20, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x20, 0x33, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x62, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x62, 0x64, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x56, 0x69, - 0x62, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x4a, 0x6f, 0x79, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x31, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x31, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x44, 0x75, 0x61, 0x6c, - 0x46, 0x6f, 0x72, 0x63, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x44, 0x75, 0x61, - 0x6c, 0x53, 0x68, 0x6f, 0x63, 0x6b, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x31, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x44, 0x75, 0x61, 0x6c, 0x53, 0x68, 0x6f, 0x63, 0x6b, 0x20, 0x33, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x41, 0x20, 0x53, 0x70, 0x6f, 0x72, - 0x74, 0x73, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x63, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x61, 0x73, 0x79, 0x20, - 0x47, 0x72, 0x69, 0x70, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x61, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, 0x6f, - 0x6d, 0x20, 0x44, 0x55, 0x58, 0x36, 0x30, 0x20, 0x4d, 0x4d, 0x4f, 0x2c, - 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x38, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, - 0x6f, 0x6d, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x62, 0x38, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, 0x6f, 0x6d, 0x20, 0x47, 0x61, 0x6d, - 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, - 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, - 0x6f, 0x6d, 0x20, 0x50, 0x33, 0x30, 0x31, 0x55, 0x20, 0x50, 0x6c, 0x61, - 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, - 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x31, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, 0x6f, - 0x6d, 0x20, 0x55, 0x31, 0x30, 0x31, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, - 0x6c, 0x65, 0x63, 0x6f, 0x6d, 0x20, 0x55, 0x33, 0x36, 0x31, 0x33, 0x4d, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, 0x6f, 0x6d, 0x20, 0x55, 0x33, 0x39, - 0x31, 0x32, 0x54, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, 0x6f, - 0x6d, 0x20, 0x55, 0x34, 0x30, 0x31, 0x33, 0x53, 0x2c, 0x61, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, - 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x45, 0x6c, 0x65, 0x63, 0x6f, 0x6d, 0x20, 0x55, 0x34, 0x31, 0x31, 0x33, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, 0x6f, 0x6d, 0x20, 0x55, 0x34, 0x31, - 0x31, 0x33, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, 0x6f, - 0x6d, 0x20, 0x57, 0x30, 0x31, 0x55, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x37, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x69, 0x6d, 0x69, 0x6e, 0x61, - 0x74, 0x6f, 0x72, 0x20, 0x41, 0x66, 0x74, 0x65, 0x72, 0x53, 0x68, 0x6f, - 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x2d, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, - 0x30, 0x30, 0x30, 0x30, 0x66, 0x36, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x69, - 0x74, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x45, 0x4d, 0x53, 0x20, 0x50, 0x72, 0x6f, 0x64, - 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x53, 0x32, 0x20, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x62, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x53, 0x4d, 0x20, 0x39, 0x31, - 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x38, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x45, 0x73, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x61, - 0x6c, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x66, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x58, 0x45, 0x51, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x34, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x38, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x45, 0x58, 0x45, 0x51, 0x20, 0x52, 0x46, 0x20, 0x47, 0x61, 0x6d, - 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, - 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, - 0x61, 0x63, 0x65, 0x6f, 0x66, 0x66, 0x20, 0x44, 0x65, 0x6c, 0x75, 0x78, - 0x65, 0x20, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, - 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x61, 0x63, 0x65, 0x6f, 0x66, - 0x66, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, - 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x43, - 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x31, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x46, 0x43, 0x38, 0x30, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x35, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x46, 0x46, 0x20, 0x47, 0x50, 0x31, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, - 0x64, 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x66, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x46, 0x69, 0x67, 0x68, 0x74, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x65, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x69, 0x67, - 0x68, 0x74, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x38, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x69, 0x67, 0x68, 0x74, - 0x70, 0x61, 0x64, 0x20, 0x54, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x35, 0x30, - 0x33, 0x36, 0x38, 0x35, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x46, 0x61, 0x6e, - 0x74, 0x61, 0x73, 0x79, 0x20, 0x58, 0x49, 0x56, 0x20, 0x4f, 0x6e, 0x6c, - 0x69, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x38, 0x30, 0x36, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x61, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x69, 0x72, 0x65, 0x73, 0x74, - 0x6f, 0x72, 0x6d, 0x2c, 0x61, 0x3a, 0x62, 0x39, 0x2c, 0x62, 0x3a, 0x62, - 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x38, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x62, 0x35, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x46, 0x69, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, - 0x6d, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x35, 0x30, 0x37, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x69, 0x72, - 0x65, 0x73, 0x74, 0x6f, 0x72, 0x6d, 0x20, 0x44, 0x33, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x6c, 0x79, 0x64, - 0x69, 0x67, 0x69, 0x20, 0x41, 0x70, 0x65, 0x78, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x35, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x46, 0x6c, 0x79, 0x64, 0x69, 0x67, 0x69, 0x20, 0x56, 0x61, - 0x64, 0x65, 0x72, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x37, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, - 0x35, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x33, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x34, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x35, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x62, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x32, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x46, 0x6c, 0x79, 0x64, 0x69, 0x67, 0x69, 0x20, 0x56, 0x61, - 0x64, 0x65, 0x72, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x34, 0x2c, - 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x35, 0x2c, 0x70, - 0x61, 0x64, 0x64, 0x6c, 0x65, 0x33, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x70, - 0x61, 0x64, 0x64, 0x6c, 0x65, 0x34, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x32, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x6c, 0x79, 0x64, 0x69, - 0x67, 0x69, 0x20, 0x56, 0x61, 0x64, 0x65, 0x72, 0x20, 0x32, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, - 0x31, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, - 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, - 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x33, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x34, - 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x38, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x47, 0x30, 0x38, 0x58, 0x55, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x36, 0x66, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x20, 0x56, 0x49, 0x42, - 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x36, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x32, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, - 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x66, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, - 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x37, 0x31, 0x38, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, - 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, - 0x20, 0x33, 0x20, 0x54, 0x75, 0x72, 0x62, 0x6f, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x64, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, - 0x6d, 0x65, 0x53, 0x69, 0x72, 0x20, 0x47, 0x33, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x35, 0x62, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x20, 0x47, 0x33, - 0x77, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, 0x64, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x20, 0x47, - 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, - 0x69, 0x72, 0x20, 0x47, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x30, 0x36, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, - 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x2d, 0x54, 0x33, 0x20, 0x32, 0x2e, - 0x30, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x65, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x73, 0x74, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x74, - 0x69, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x37, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x36, - 0x31, 0x36, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x74, 0x6f, 0x70, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x74, 0x6f, 0x70, - 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x75, 0x6e, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x36, 0x32, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, - 0x65, 0x74, 0x65, 0x6c, 0x20, 0x47, 0x54, 0x30, 0x30, 0x34, 0x20, 0x30, - 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x31, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x47, 0x61, 0x6d, 0x6f, 0x32, 0x20, 0x44, 0x69, 0x76, 0x61, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, - 0x30, 0x30, 0x61, 0x38, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x74, 0x6f, 0x72, - 0x20, 0x43, 0x6c, 0x61, 0x77, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x39, 0x31, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x43, 0x31, - 0x30, 0x30, 0x58, 0x46, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x39, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x65, 0x6e, 0x69, - 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x65, 0x6e, 0x69, 0x75, 0x73, - 0x20, 0x4d, 0x61, 0x78, 0x66, 0x69, 0x72, 0x65, 0x20, 0x42, 0x6c, 0x61, - 0x7a, 0x65, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x31, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x65, 0x6e, 0x69, - 0x75, 0x73, 0x20, 0x4d, 0x61, 0x78, 0x66, 0x69, 0x72, 0x65, 0x20, 0x47, - 0x72, 0x61, 0x6e, 0x64, 0x69, 0x61, 0x73, 0x20, 0x31, 0x32, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x63, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x33, 0x33, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x47, 0x65, 0x6e, 0x69, 0x75, 0x73, 0x20, 0x4d, 0x61, 0x78, - 0x46, 0x69, 0x72, 0x65, 0x20, 0x47, 0x72, 0x61, 0x6e, 0x64, 0x69, 0x61, - 0x73, 0x20, 0x31, 0x32, 0x56, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x47, 0x45, - 0x39, 0x30, 0x39, 0x20, 0x52, 0x65, 0x63, 0x6f, 0x69, 0x6c, 0x2c, 0x61, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x66, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x32, 0x38, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x47, 0x69, 0x6f, 0x74, 0x65, 0x63, 0x6b, 0x20, 0x50, 0x6c, - 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, 0x32, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x63, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x69, - 0x6f, 0x74, 0x65, 0x63, 0x6b, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, - 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x63, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x47, 0x69, 0x6f, 0x74, 0x65, 0x63, 0x6b, 0x20, 0x50, 0x53, 0x33, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x66, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x33, 0x38, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x47, 0x69, 0x6f, 0x74, 0x65, 0x63, 0x6b, 0x20, 0x56, 0x58, - 0x32, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, - 0x34, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x47, 0x69, 0x6f, 0x74, 0x65, 0x63, 0x6b, 0x20, - 0x56, 0x58, 0x32, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x36, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x50, 0x20, 0x58, 0x49, 0x44, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x34, 0x31, - 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x47, 0x50, 0x44, 0x20, 0x57, 0x69, 0x6e, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, - 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x62, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, - 0x50, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x37, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, 0x61, 0x76, 0x69, 0x73, 0x20, 0x44, - 0x65, 0x73, 0x74, 0x72, 0x6f, 0x79, 0x65, 0x72, 0x20, 0x54, 0x69, 0x6c, - 0x74, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, 0x61, 0x76, 0x69, 0x73, - 0x20, 0x45, 0x6c, 0x69, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x20, - 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, 0x61, 0x76, - 0x69, 0x73, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x64, 0x20, 0x50, - 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x2d, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, 0x65, 0x65, 0x6e, - 0x41, 0x73, 0x69, 0x61, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x62, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x54, 0x32, 0x61, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x61, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x61, 0x6d, 0x61, 0x20, 0x53, - 0x63, 0x6f, 0x72, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x61, 0x74, 0x73, - 0x75, 0x6e, 0x65, 0x20, 0x4d, 0x69, 0x6b, 0x75, 0x20, 0x53, 0x68, 0x6f, - 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x65, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x61, 0x76, 0x69, 0x74, 0x20, 0x48, - 0x56, 0x20, 0x47, 0x36, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, - 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x45, - 0x58, 0x54, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, 0x31, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x38, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x69, 0x74, 0x42, 0x6f, 0x78, - 0x20, 0x45, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x74, 0x68, - 0x75, 0x6c, 0x68, 0x75, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, - 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, - 0x4a, 0x44, 0x20, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, - 0x20, 0x44, 0x4f, 0x41, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, - 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, - 0x65, 0x72, 0x20, 0x32, 0x30, 0x31, 0x36, 0x20, 0x50, 0x53, 0x33, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, - 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, - 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, - 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, - 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x33, 0x20, 0x50, - 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, - 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x35, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, - 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, - 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x34, - 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, - 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, - 0x20, 0x34, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, - 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, - 0x65, 0x72, 0x20, 0x35, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, - 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, - 0x61, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x36, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, - 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, - 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, - 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x62, 0x61, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, - 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, - 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, - 0x69, 0x6e, 0x67, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x6d, 0x69, - 0x6e, 0x69, 0x20, 0x34, 0x20, 0x28, 0x50, 0x53, 0x33, 0x29, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, - 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, - 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x20, 0x34, 0x20, 0x28, 0x50, 0x53, 0x34, - 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, - 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x33, 0x57, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x20, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, - 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, - 0x45, 0x58, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, - 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x4d, - 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, - 0x66, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, - 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x56, 0x33, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x32, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x20, 0x56, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x47, 0x72, 0x69, 0x70, 0x20, - 0x54, 0x41, 0x43, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, - 0x30, 0x30, 0x30, 0x30, 0x61, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, - 0x69, 0x20, 0x4d, 0x69, 0x6b, 0x75, 0x20, 0x50, 0x72, 0x6f, 0x6a, 0x65, - 0x63, 0x74, 0x20, 0x44, 0x69, 0x76, 0x61, 0x20, 0x58, 0x20, 0x48, 0x44, - 0x20, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x61, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x4d, 0x69, - 0x6b, 0x75, 0x20, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x44, - 0x69, 0x76, 0x61, 0x20, 0x58, 0x20, 0x48, 0x44, 0x20, 0x50, 0x53, 0x34, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, 0x48, - 0x61, 0x74, 0x73, 0x75, 0x6e, 0x65, 0x20, 0x4d, 0x69, 0x6b, 0x75, 0x20, - 0x46, 0x54, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, - 0x61, 0x64, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, - 0x61, 0x64, 0x20, 0x33, 0x20, 0x54, 0x75, 0x72, 0x62, 0x6f, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x34, 0x64, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, 0x61, 0x64, 0x20, 0x41, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, 0x43, 0x20, 0x45, 0x6e, 0x67, 0x69, - 0x6e, 0x65, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, 0x6f, 0x6b, 0x6b, 0x65, 0x6e, - 0x20, 0x54, 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x6e, 0x74, 0x20, - 0x44, 0x58, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x32, 0x33, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, 0x53, 0x34, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x4c, - 0x69, 0x67, 0x68, 0x74, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, - 0x66, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, - 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, - 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, - 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, - 0x20, 0x50, 0x72, 0x6f, 0x20, 0x33, 0x50, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, - 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x34, 0x62, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, - 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, - 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x33, 0x57, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x36, 0x61, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, - 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x34, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, - 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x34, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x61, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, - 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x34, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x62, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, - 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x34, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, - 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x34, - 0x20, 0x56, 0x4c, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, - 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, - 0x20, 0x50, 0x72, 0x6f, 0x20, 0x34, 0x20, 0x56, 0x4c, 0x58, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, - 0x66, 0x30, 0x30, 0x30, 0x30, 0x33, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, - 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, - 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x4e, 0x33, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x61, 0x65, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, - 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x4e, 0x34, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, - 0x30, 0x30, 0x38, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, - 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, - 0x50, 0x72, 0x6f, 0x20, 0x50, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x61, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, - 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, - 0x20, 0x50, 0x72, 0x6f, 0x20, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, - 0x66, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, - 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, - 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x53, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, - 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, - 0x50, 0x72, 0x6f, 0x20, 0x56, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x35, 0x62, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, - 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, - 0x56, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, - 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, - 0x20, 0x56, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x61, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, - 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, - 0x6f, 0x20, 0x56, 0x48, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, - 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, - 0x65, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x56, 0x58, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x66, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, - 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, - 0x50, 0x72, 0x6f, 0x20, 0x56, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, - 0x30, 0x30, 0x39, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, - 0x54, 0x41, 0x43, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, - 0x30, 0x30, 0x30, 0x30, 0x63, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, - 0x69, 0x20, 0x54, 0x61, 0x69, 0x6b, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, - 0x66, 0x30, 0x30, 0x30, 0x30, 0x63, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, - 0x72, 0x69, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x70, - 0x61, 0x64, 0x20, 0x33, 0x54, 0x50, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, - 0x66, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, - 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x33, 0x57, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x48, 0x6f, 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x34, 0x20, 0x46, 0x50, - 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x34, - 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x70, 0x61, - 0x64, 0x20, 0x34, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, - 0x69, 0x70, 0x61, 0x64, 0x20, 0x41, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, - 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, - 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x45, 0x58, 0x54, 0x32, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x65, 0x65, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x4d, 0x69, - 0x6e, 0x69, 0x20, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x70, 0x61, - 0x64, 0x20, 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, - 0x70, 0x61, 0x64, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x34, 0x32, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x48, 0x79, 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x41, 0x64, 0x6d, - 0x69, 0x72, 0x61, 0x6c, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x2b, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x2b, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x2d, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x62, 0x38, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x34, 0x32, 0x65, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x62, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x48, 0x79, 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x4e, 0x36, 0x34, - 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x65, 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x79, 0x70, - 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, - 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x65, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x61, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6b, 0x69, - 0x6e, 0x20, 0x54, 0x72, 0x6f, 0x6f, 0x70, 0x65, 0x72, 0x20, 0x32, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, 0x31, - 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x69, 0x42, - 0x75, 0x66, 0x66, 0x61, 0x6c, 0x6f, 0x20, 0x41, 0x43, 0x30, 0x32, 0x20, - 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, - 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, 0x31, 0x64, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x69, 0x42, 0x75, 0x66, 0x66, - 0x61, 0x6c, 0x6f, 0x20, 0x42, 0x53, 0x47, 0x50, 0x31, 0x32, 0x30, 0x34, - 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, - 0x31, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x69, - 0x42, 0x75, 0x66, 0x66, 0x61, 0x6c, 0x6f, 0x20, 0x42, 0x53, 0x47, 0x50, - 0x31, 0x32, 0x30, 0x34, 0x50, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x63, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x69, 0x44, 0x72, 0x6f, 0x69, 0x64, 0x43, 0x6f, - 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x36, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x39, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x36, 0x39, 0x36, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x69, 0x44, 0x72, 0x6f, 0x69, 0x64, 0x43, 0x6f, 0x6e, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x62, 0x35, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x49, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x20, 0x42, 0x6c, 0x61, - 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x6a, 0x75, 0x73, - 0x74, 0x69, 0x63, 0x65, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x38, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x35, 0x31, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x20, 0x41, 0x63, - 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, - 0x66, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x49, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x20, 0x41, 0x78, 0x69, - 0x73, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, - 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, - 0x72, 0x41, 0x63, 0x74, 0x20, 0x41, 0x78, 0x69, 0x73, 0x50, 0x61, 0x64, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x61, 0x63, 0x74, - 0x20, 0x47, 0x6f, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, - 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x39, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, - 0x74, 0x20, 0x48, 0x61, 0x6d, 0x6d, 0x65, 0x72, 0x68, 0x65, 0x61, 0x64, - 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x61, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, - 0x74, 0x20, 0x48, 0x61, 0x6d, 0x6d, 0x65, 0x72, 0x68, 0x65, 0x61, 0x64, - 0x20, 0x46, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x3a, 0x62, - 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x66, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, - 0x20, 0x48, 0x61, 0x6d, 0x6d, 0x65, 0x72, 0x68, 0x65, 0x61, 0x64, 0x20, - 0x46, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x35, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x66, 0x64, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x35, 0x33, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x20, - 0x50, 0x72, 0x6f, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, - 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x63, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x49, 0x70, 0x65, 0x67, 0x61, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x39, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x49, 0x70, 0x65, 0x67, 0x61, 0x20, 0x50, 0x47, 0x39, 0x30, - 0x32, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x39, 0x31, 0x39, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x70, 0x65, 0x67, - 0x61, 0x20, 0x50, 0x47, 0x39, 0x30, 0x38, 0x37, 0x2c, 0x2b, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x2b, 0x61, 0x35, 0x2c, 0x2d, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, - 0x28, 0x4c, 0x29, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x6f, 0x79, - 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x52, 0x29, 0x2c, 0x2b, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x2b, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x2d, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x2d, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4a, 0x6f, 0x79, 0x70, 0x61, 0x64, 0x20, 0x41, 0x64, 0x61, - 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x64, 0x31, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x6f, 0x79, 0x70, - 0x61, 0x64, 0x20, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x20, 0x53, 0x68, 0x6f, - 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x31, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x30, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x50, 0x44, 0x20, 0x46, 0x46, - 0x42, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x59, 0x53, 0x20, 0x41, 0x64, - 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, - 0x30, 0x30, 0x38, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x59, 0x53, 0x20, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, - 0x30, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x4b, 0x41, 0x44, 0x45, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, - 0x32, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4b, 0x65, 0x69, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x3a, - 0x62, 0x35, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4b, 0x69, 0x6e, 0x67, - 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x64, 0x31, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x65, 0x61, 0x64, 0x65, - 0x72, 0x73, 0x68, 0x69, 0x70, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, - 0x69, 0x63, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x63, 0x33, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x63, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x31, 0x63, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, - 0x63, 0x68, 0x20, 0x43, 0x68, 0x69, 0x6c, 0x6c, 0x53, 0x74, 0x72, 0x65, - 0x61, 0x6d, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x32, 0x63, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, - 0x63, 0x68, 0x20, 0x43, 0x6f, 0x72, 0x64, 0x6c, 0x65, 0x73, 0x73, 0x20, - 0x50, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x63, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, - 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x72, 0x64, - 0x6c, 0x65, 0x73, 0x73, 0x20, 0x57, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x6e, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x63, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x44, 0x75, - 0x61, 0x6c, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x64, 0x63, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, 0x33, - 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, - 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, 0x35, 0x31, 0x30, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x63, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, - 0x35, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x63, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, - 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, 0x37, 0x31, 0x30, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, - 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, - 0x46, 0x37, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x63, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, - 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x50, 0x72, 0x65, 0x63, - 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x63, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, - 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x57, 0x69, 0x6e, 0x67, 0x4d, - 0x61, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x62, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, - 0x63, 0x68, 0x20, 0x57, 0x69, 0x6e, 0x67, 0x4d, 0x61, 0x6e, 0x20, 0x41, - 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x7e, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x32, 0x7e, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x61, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, - 0x68, 0x20, 0x57, 0x69, 0x6e, 0x67, 0x4d, 0x61, 0x6e, 0x20, 0x52, 0x75, - 0x6d, 0x62, 0x6c, 0x65, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x79, 0x6e, - 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x32, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, - 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, - 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, 0x45, 0x20, 0x53, 0x20, 0x50, - 0x6c, 0x75, 0x73, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, - 0x35, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, - 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x46, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, 0x45, 0x20, 0x53, 0x20, - 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x35, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x43, 0x54, 0x52, - 0x4c, 0x52, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x36, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, - 0x74, 0x7a, 0x20, 0x43, 0x54, 0x52, 0x4c, 0x52, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, - 0x37, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, - 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, - 0x70, 0x61, 0x64, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, 0x53, 0x33, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x38, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, - 0x67, 0x68, 0x74, 0x70, 0x61, 0x64, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, - 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, - 0x30, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, - 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x20, - 0x41, 0x6c, 0x70, 0x68, 0x61, 0x20, 0x50, 0x53, 0x33, 0x09, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x62, - 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, 0x45, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, - 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, 0x45, 0x20, 0x53, 0x20, 0x50, 0x53, - 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, - 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, - 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, - 0x45, 0x20, 0x53, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x33, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, - 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, 0x45, 0x32, 0x20, 0x50, 0x53, 0x33, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x38, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, 0x45, - 0x32, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x32, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, - 0x61, 0x74, 0x7a, 0x20, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x20, 0x43, 0x54, - 0x52, 0x4c, 0x52, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, - 0x38, 0x32, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, - 0x7a, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x20, 0x42, 0x72, 0x61, 0x77, 0x6c, 0x70, 0x61, 0x64, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x37, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, - 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, - 0x61, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, - 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x38, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, - 0x20, 0x53, 0x46, 0x49, 0x56, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, - 0x38, 0x30, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, - 0x7a, 0x20, 0x53, 0x46, 0x56, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, - 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, - 0x41, 0x6c, 0x70, 0x68, 0x61, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x38, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, - 0x74, 0x7a, 0x20, 0x53, 0x74, 0x72, 0x65, 0x65, 0x74, 0x20, 0x46, 0x69, - 0x67, 0x68, 0x74, 0x65, 0x72, 0x20, 0x34, 0x20, 0x58, 0x62, 0x6f, 0x78, - 0x20, 0x33, 0x36, 0x30, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x53, 0x74, - 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x54, 0x45, 0x32, - 0x20, 0x50, 0x53, 0x33, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x38, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x54, 0x45, 0x32, - 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x61, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4d, 0x61, 0x74, 0x72, 0x69, 0x63, 0x6f, 0x6d, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x62, 0x62, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, - 0x78, 0x4a, 0x6f, 0x79, 0x70, 0x61, 0x64, 0x20, 0x56, 0x69, 0x72, 0x74, - 0x75, 0x61, 0x6c, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x38, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x41, 0x72, - 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x35, 0x2c, 0x79, 0x3a, 0x62, 0x36, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, - 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, 0x30, 0x30, 0x33, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x46, 0x31, - 0x30, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, - 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x46, 0x33, 0x30, 0x30, 0x20, 0x41, - 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, - 0x68, 0x20, 0x46, 0x33, 0x30, 0x30, 0x20, 0x45, 0x6c, 0x69, 0x74, 0x65, - 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x34, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, - 0x6c, 0x61, 0x73, 0x68, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, - 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x31, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, - 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x47, 0x61, 0x6d, 0x65, - 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, 0x30, 0x30, 0x37, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x4d, - 0x61, 0x67, 0x69, 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x64, 0x32, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, - 0x68, 0x20, 0x4d, 0x61, 0x67, 0x69, 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, - 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x61, 0x37, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x4d, 0x61, 0x67, - 0x69, 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x39, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, - 0x61, 0x73, 0x68, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x53, - 0x61, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x65, 0x38, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x57, - 0x69, 0x69, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, - 0x57, 0x69, 0x69, 0x20, 0x44, 0x6f, 0x6c, 0x70, 0x68, 0x69, 0x6e, 0x42, - 0x61, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, - 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x57, 0x69, 0x69, 0x20, - 0x55, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x34, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x65, 0x67, 0x61, 0x20, 0x44, 0x72, - 0x69, 0x76, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x61, 0x65, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x65, 0x67, 0x61, - 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x39, 0x39, 0x30, - 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4d, 0x65, 0x67, 0x61, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, - 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x44, 0x75, 0x61, 0x6c, - 0x20, 0x53, 0x74, 0x72, 0x69, 0x6b, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x33, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x7e, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, - 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, - 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, - 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, - 0x6e, 0x64, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, - 0x73, 0x6f, 0x66, 0x74, 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, - 0x64, 0x65, 0x72, 0x20, 0x46, 0x72, 0x65, 0x65, 0x73, 0x74, 0x79, 0x6c, - 0x65, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, - 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, - 0x6e, 0x64, 0x65, 0x72, 0x20, 0x50, 0x6c, 0x75, 0x67, 0x20, 0x61, 0x6e, - 0x64, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x6c, - 0x6c, 0x65, 0x72, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x43, 0x61, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x33, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x4c, 0x47, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, - 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, 0x33, 0x65, 0x66, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, - 0x4c, 0x47, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x20, 0x54, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x39, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x38, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4d, 0x4c, 0x47, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x6f, 0x63, - 0x75, 0x74, 0x65, 0x20, 0x4d, 0x30, 0x35, 0x33, 0x2c, 0x61, 0x3a, 0x62, - 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, - 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, - 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x35, 0x38, 0x39, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4d, 0x6f, 0x67, 0x61, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x31, 0x36, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4d, 0x6f, 0x67, 0x61, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, - 0x64, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x6f, 0x67, 0x61, 0x20, 0x50, 0x72, 0x6f, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x61, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x6f, 0x67, 0x61, 0x20, - 0x58, 0x50, 0x35, 0x41, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x62, 0x38, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4d, 0x6f, 0x67, 0x61, 0x20, 0x58, 0x50, 0x35, 0x41, 0x20, 0x50, - 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x61, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x6f, 0x67, 0x61, 0x20, - 0x58, 0x50, 0x35, 0x58, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x62, 0x38, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4d, 0x6f, 0x67, 0x61, 0x20, 0x58, 0x50, 0x35, 0x58, 0x20, 0x50, - 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x36, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x50, 0x2d, 0x38, 0x38, - 0x36, 0x36, 0x20, 0x53, 0x75, 0x70, 0x65, 0x72, 0x20, 0x44, 0x75, 0x61, - 0x6c, 0x20, 0x42, 0x6f, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x31, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x55, 0x53, - 0x49, 0x41, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x20, 0x32, 0x20, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x44, - 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x31, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x37, 0x30, - 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x36, - 0x34, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x69, 0x64, 0x2c, 0x2b, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x2b, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x2d, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x2d, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x62, 0x35, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x61, 0x63, 0x6f, 0x6e, - 0x20, 0x47, 0x43, 0x20, 0x34, 0x30, 0x30, 0x45, 0x53, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, - 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x36, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, - 0x61, 0x63, 0x6f, 0x6e, 0x20, 0x52, 0x65, 0x76, 0x6f, 0x6c, 0x75, 0x74, - 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x20, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, - 0x62, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4e, 0x61, 0x63, 0x6f, 0x6e, 0x20, 0x52, 0x65, 0x76, 0x6f, 0x6c, 0x75, - 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x49, 0x6e, 0x66, 0x69, 0x6e, 0x69, 0x74, - 0x79, 0x20, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x61, 0x63, 0x6f, - 0x6e, 0x20, 0x52, 0x65, 0x76, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, - 0x20, 0x55, 0x6e, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x20, 0x50, - 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x62, 0x64, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x65, 0x62, 0x75, 0x6c, 0x61, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x65, 0x62, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x65, 0x47, 0x63, 0x6f, 0x6e, 0x20, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x61, 0x32, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, - 0x37, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x65, 0x66, 0x62, - 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4e, 0x45, 0x4f, 0x20, 0x53, 0x45, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x31, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x34, 0x37, 0x34, 0x65, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x65, - 0x6f, 0x47, 0x65, 0x6f, 0x20, 0x58, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, - 0x65, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, - 0x32, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x34, 0x62, 0x34, 0x36, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4e, 0x45, 0x53, 0x20, 0x32, 0x20, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x31, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x33, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x45, 0x53, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x31, 0x38, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4e, 0x45, 0x58, 0x49, 0x4c, 0x55, 0x58, 0x20, 0x47, 0x61, 0x6d, - 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, - 0x45, 0x58, 0x54, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x65, 0x78, - 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x47, 0x44, 0x53, 0x2c, 0x61, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, - 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x6f, 0x73, 0x74, 0x72, - 0x6f, 0x6d, 0x6f, 0x20, 0x4e, 0x34, 0x35, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x53, 0x4f, - 0x20, 0x4e, 0x36, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x62, 0x38, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, - 0x32, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x37, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, - 0x31, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x53, 0x4f, 0x20, 0x53, 0x4e, 0x45, - 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, - 0x39, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x37, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x56, - 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x39, 0x2c, 0x79, 0x3a, 0x62, - 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, - 0x20, 0x53, 0x68, 0x69, 0x65, 0x6c, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x39, - 0x2c, 0x62, 0x3a, 0x62, 0x38, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x37, - 0x2c, 0x79, 0x3a, 0x62, 0x36, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, - 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x56, - 0x49, 0x44, 0x49, 0x41, 0x20, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2d, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x79, 0x6b, 0x6f, 0x20, 0x41, 0x69, 0x72, - 0x20, 0x46, 0x6c, 0x6f, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, - 0x62, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4e, 0x79, 0x6b, 0x6f, 0x20, 0x41, 0x69, 0x72, 0x66, 0x6c, 0x6f, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x64, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x79, 0x6b, - 0x6f, 0x20, 0x41, 0x69, 0x72, 0x66, 0x6c, 0x6f, 0x20, 0x50, 0x53, 0x33, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x37, 0x39, 0x31, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4e, 0x79, 0x6b, 0x6f, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x70, 0x61, - 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x38, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4f, 0x6e, 0x6c, 0x69, 0x76, 0x65, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4f, 0x6e, 0x79, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, - 0x39, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4f, 0x6e, 0x7a, 0x61, 0x20, 0x43, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, 0x31, 0x36, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4f, 0x6e, 0x7a, - 0x61, 0x20, 0x54, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x64, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4f, 0x50, 0x50, 0x20, 0x50, 0x53, - 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x32, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4f, 0x55, 0x59, 0x41, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x38, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x78, 0x3a, - 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x66, 0x36, 0x30, 0x65, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x50, 0x34, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x43, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, - 0x65, 0x30, 0x30, 0x30, 0x30, 0x38, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, - 0x50, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x70, 0x61, 0x64, 0x20, 0x50, - 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, - 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, 0x20, 0x50, 0x53, - 0x33, 0x20, 0x56, 0x65, 0x72, 0x73, 0x75, 0x73, 0x20, 0x46, 0x69, 0x67, - 0x68, 0x74, 0x69, 0x6e, 0x67, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, - 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x50, 0x6c, 0x61, 0x79, 0x53, 0x65, 0x67, 0x61, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x37, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, - 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, - 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x64, 0x61, 0x30, 0x63, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, - 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, - 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x32, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6c, - 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x66, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x31, 0x38, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x39, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, - 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, - 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x37, 0x31, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, - 0x56, 0x69, 0x74, 0x61, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, - 0x64, 0x63, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x41, 0x20, 0x50, - 0x72, 0x6f, 0x20, 0x45, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x30, 0x36, 0x30, 0x30, - 0x30, 0x30, 0x64, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, 0x72, - 0x41, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x33, 0x61, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x41, - 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x38, 0x34, 0x63, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x72, 0x65, 0x63, - 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x39, 0x35, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x72, 0x6f, - 0x20, 0x45, 0x6c, 0x69, 0x74, 0x65, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, - 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x35, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, - 0x72, 0x6f, 0x20, 0x45, 0x78, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x66, 0x33, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x50, 0x72, 0x6f, 0x20, 0x45, 0x78, 0x20, 0x6d, 0x69, 0x6e, - 0x69, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x37, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x72, 0x6f, 0x20, 0x45, 0x78, - 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, - 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x65, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x72, - 0x6f, 0x35, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x31, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, - 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x37, 0x35, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x50, 0x53, 0x31, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, - 0x53, 0x32, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x32, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, - 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x38, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, - 0x53, 0x32, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, - 0x38, 0x38, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x32, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, - 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, - 0x53, 0x32, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x39, 0x64, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x50, 0x53, 0x32, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x61, - 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x32, - 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x20, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x61, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, - 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x63, 0x66, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x66, 0x39, 0x30, - 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, - 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x30, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x7e, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x31, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x37, 0x35, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x38, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x79, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, - 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x61, 0x32, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x37, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x31, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x31, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x33, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x38, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x39, 0x31, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, - 0x30, 0x30, 0x61, 0x39, 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x61, 0x61, 0x35, 0x37, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, - 0x30, 0x30, 0x66, 0x32, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x66, 0x33, 0x31, 0x63, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, - 0x30, 0x30, 0x66, 0x34, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x66, 0x35, 0x31, 0x63, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, - 0x30, 0x30, 0x66, 0x37, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x32, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, 0x65, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x61, 0x31, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x61, 0x30, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x34, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, - 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x74, 0x6f, 0x75, 0x63, 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, - 0x63, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x65, 0x36, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x74, 0x6f, 0x75, 0x63, - 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x66, 0x32, 0x30, 0x64, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, - 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, - 0x31, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x74, - 0x6f, 0x75, 0x63, 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x50, 0x53, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, - 0x62, 0x61, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, 0x62, - 0x61, 0x20, 0x32, 0x50, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, 0x62, - 0x61, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, 0x74, 0x69, - 0x63, 0x6b, 0x20, 0x31, 0x30, 0x30, 0x38, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, - 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x31, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, - 0x61, 0x6e, 0x62, 0x61, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, - 0x53, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x34, 0x30, 0x31, 0x38, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, 0x63, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, 0x62, 0x61, 0x20, 0x44, - 0x72, 0x61, 0x67, 0x6f, 0x6e, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, - 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, - 0x32, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, - 0x61, 0x6e, 0x62, 0x61, 0x20, 0x44, 0x72, 0x6f, 0x6e, 0x65, 0x20, 0x41, - 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x32, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, 0x62, 0x61, 0x20, - 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x51, 0x61, 0x6e, 0x62, 0x61, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x34, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x51, 0x61, 0x6e, 0x62, 0x61, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x20, 0x51, 0x34, 0x52, 0x41, 0x46, 0x2c, 0x61, 0x3a, - 0x62, 0x35, 0x2c, 0x62, 0x3a, 0x62, 0x36, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, - 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, - 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, - 0x6e, 0x62, 0x61, 0x20, 0x4f, 0x62, 0x73, 0x69, 0x64, 0x69, 0x61, 0x6e, - 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, 0x74, 0x69, 0x63, - 0x6b, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, 0x63, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, 0x62, 0x61, - 0x20, 0x4f, 0x62, 0x73, 0x69, 0x64, 0x69, 0x61, 0x6e, 0x20, 0x41, 0x72, - 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x50, - 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x61, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x36, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x31, 0x20, 0x4d, 0x6f, 0x62, 0x69, - 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x32, 0x36, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x52, 0x61, 0x64, 0x69, 0x6f, 0x53, 0x68, 0x61, 0x63, 0x6b, 0x2c, - 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x66, 0x66, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x34, 0x37, - 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x52, 0x61, 0x6d, 0x6f, 0x78, 0x20, 0x46, 0x50, 0x53, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, - 0x33, 0x44, 0x4f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, - 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x36, 0x39, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x33, 0x44, 0x4f, 0x20, - 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, - 0x6e, 0x65, 0x74, 0x20, 0x44, 0x72, 0x65, 0x61, 0x6d, 0x63, 0x61, 0x73, - 0x74, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x35, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x47, 0x43, 0x20, - 0x61, 0x6e, 0x64, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x41, 0x64, 0x61, 0x70, - 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x2b, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, - 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, - 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x47, 0x43, 0x20, 0x61, - 0x6e, 0x64, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x37, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x2b, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, - 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, - 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, - 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x4a, 0x61, 0x67, 0x75, 0x61, - 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, - 0x78, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, - 0x4e, 0x45, 0x53, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x37, 0x2c, 0x62, 0x3a, 0x62, 0x36, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, - 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x50, 0x53, 0x31, 0x20, - 0x61, 0x6e, 0x64, 0x20, 0x50, 0x53, 0x32, 0x20, 0x41, 0x64, 0x61, 0x70, - 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x35, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x34, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x53, - 0x61, 0x74, 0x75, 0x72, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, - 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, - 0x6e, 0x65, 0x74, 0x20, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20, 0x32, 0x2e, 0x30, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, - 0x65, 0x74, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x41, 0x64, 0x61, 0x70, - 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, - 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, - 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, - 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, - 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x35, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, - 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, - 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, - 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, - 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x56, 0x65, 0x63, 0x74, 0x72, - 0x65, 0x78, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, - 0x57, 0x69, 0x69, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, - 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, - 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x32, 0x63, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x57, 0x69, 0x69, 0x20, - 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x41, 0x64, 0x61, 0x70, - 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, - 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, - 0x6e, 0x65, 0x74, 0x20, 0x57, 0x69, 0x69, 0x20, 0x43, 0x6c, 0x61, 0x73, - 0x73, 0x69, 0x63, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x35, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x48, 0x79, - 0x64, 0x72, 0x61, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x66, 0x38, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x62, 0x66, 0x30, - 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x4b, 0x69, 0x73, 0x68, - 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x36, 0x2c, 0x62, 0x3a, 0x62, 0x37, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x39, 0x2c, - 0x79, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, - 0x7a, 0x65, 0x72, 0x20, 0x50, 0x61, 0x6e, 0x74, 0x68, 0x65, 0x72, 0x61, - 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x50, - 0x61, 0x6e, 0x74, 0x68, 0x65, 0x72, 0x61, 0x20, 0x50, 0x53, 0x34, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, 0x69, 0x6a, 0x75, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, - 0x69, 0x6a, 0x75, 0x20, 0x4d, 0x6f, 0x62, 0x69, 0x6c, 0x65, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x37, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, - 0x69, 0x6a, 0x75, 0x20, 0x4d, 0x6f, 0x62, 0x69, 0x6c, 0x65, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x37, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, - 0x69, 0x6a, 0x75, 0x20, 0x54, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, - 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, 0x69, 0x6a, 0x75, 0x20, 0x54, 0x45, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, - 0x69, 0x6a, 0x75, 0x20, 0x55, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, - 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, 0x69, 0x6a, 0x75, 0x20, 0x55, 0x45, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, - 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x69, 0x67, 0x68, - 0x74, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, - 0x53, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x2b, 0x61, 0x32, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x39, 0x32, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x34, 0x37, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x20, 0x42, 0x69, 0x74, 0x20, 0x53, - 0x65, 0x67, 0x61, 0x20, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, - 0x65, 0x74, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, - 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x62, 0x64, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x33, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x6c, 0x69, - 0x6e, 0x6b, 0x20, 0x53, 0x65, 0x67, 0x61, 0x20, 0x53, 0x61, 0x74, 0x75, - 0x72, 0x6e, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, - 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x64, 0x31, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x35, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x6c, - 0x69, 0x6e, 0x6b, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x55, 0x53, - 0x42, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x50, - 0x6f, 0x72, 0x74, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x62, 0x38, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, - 0x39, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x37, 0x2c, 0x62, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x52, 0x65, 0x74, 0x72, 0x6f, 0x55, 0x53, 0x42, 0x20, 0x52, 0x65, 0x74, - 0x72, 0x6f, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x35, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x55, 0x53, 0x42, 0x20, - 0x53, 0x75, 0x70, 0x65, 0x72, 0x20, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x50, - 0x6f, 0x72, 0x74, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x35, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x38, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x36, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x52, 0x65, 0x76, 0x65, 0x6e, 0x67, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, - 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x76, 0x6f, - 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, - 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x64, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, - 0x65, 0x76, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x72, - 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x33, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x76, 0x6f, 0x6c, 0x75, 0x74, 0x69, - 0x6f, 0x6e, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, 0x63, - 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, 0x63, - 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x66, 0x65, 0x66, 0x61, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, 0x63, - 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x65, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, 0x63, 0x6b, 0x20, 0x43, - 0x61, 0x6e, 0x64, 0x79, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, 0x63, - 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, 0x50, 0x53, 0x33, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, - 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x32, 0x66, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x52, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, 0x50, - 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x38, 0x37, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x52, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, - 0x79, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x65, 0x33, 0x31, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, - 0x4f, 0x47, 0x20, 0x43, 0x68, 0x61, 0x6b, 0x72, 0x61, 0x6d, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, - 0x65, 0x35, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x4f, 0x47, 0x20, 0x43, 0x68, 0x61, - 0x6b, 0x72, 0x61, 0x6d, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x31, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, - 0x4f, 0x47, 0x20, 0x43, 0x68, 0x61, 0x6b, 0x72, 0x61, 0x6d, 0x20, 0x43, - 0x6f, 0x72, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, - 0x62, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x31, 0x61, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x4f, - 0x47, 0x20, 0x43, 0x68, 0x61, 0x6b, 0x72, 0x61, 0x6d, 0x20, 0x58, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x61, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x4f, 0x47, 0x20, 0x43, 0x68, - 0x61, 0x6b, 0x72, 0x61, 0x6d, 0x20, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x31, 0x63, 0x31, - 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x52, 0x4f, 0x47, 0x20, 0x43, 0x68, 0x61, 0x6b, 0x72, 0x61, - 0x6d, 0x20, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x64, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x75, - 0x6d, 0x62, 0x6c, 0x65, 0x20, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x39, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, - 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x53, 0x61, 0x62, 0x65, 0x72, 0x74, 0x6f, 0x6f, 0x74, 0x68, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, - 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x53, 0x61, 0x62, 0x65, 0x72, 0x74, 0x6f, 0x6f, 0x74, 0x68, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x66, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x43, 0x79, 0x62, - 0x6f, 0x72, 0x67, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x33, 0x66, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, - 0x6b, 0x20, 0x43, 0x79, 0x62, 0x6f, 0x72, 0x67, 0x20, 0x56, 0x2e, 0x31, - 0x20, 0x47, 0x61, 0x6d, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, - 0x6b, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x41, 0x6e, 0x61, 0x6c, 0x6f, - 0x67, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, - 0x50, 0x32, 0x32, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, - 0x62, 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, - 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, - 0x32, 0x35, 0x30, 0x30, 0x20, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x20, 0x52, - 0x75, 0x6d, 0x62, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x35, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, - 0x74, 0x65, 0x6b, 0x20, 0x50, 0x32, 0x36, 0x30, 0x30, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x64, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, - 0x65, 0x6b, 0x20, 0x50, 0x32, 0x36, 0x30, 0x30, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, - 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x32, 0x39, 0x30, 0x30, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x66, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x33, 0x32, - 0x30, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, - 0x20, 0x50, 0x34, 0x38, 0x30, 0x20, 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, - 0x38, 0x38, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, - 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x30, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x39, 0x39, 0x30, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x36, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x53, 0x31, 0x30, - 0x30, 0x30, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, - 0x66, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x53, - 0x32, 0x37, 0x30, 0x30, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, - 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x38, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, - 0x61, 0x6d, 0x73, 0x75, 0x6e, 0x67, 0x20, 0x45, 0x49, 0x47, 0x50, 0x32, - 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x6e, 0x77, 0x61, - 0x20, 0x45, 0x61, 0x73, 0x79, 0x20, 0x47, 0x72, 0x69, 0x70, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x53, 0x61, 0x6e, 0x77, 0x61, 0x20, 0x4d, 0x69, 0x63, 0x72, 0x6f, - 0x20, 0x47, 0x72, 0x69, 0x70, 0x20, 0x50, 0x33, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x31, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x53, 0x61, 0x6e, 0x77, 0x61, 0x20, 0x4d, 0x69, 0x63, - 0x72, 0x6f, 0x20, 0x47, 0x72, 0x69, 0x70, 0x20, 0x50, 0x72, 0x6f, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x53, 0x61, 0x6e, 0x77, 0x61, 0x20, 0x4d, 0x69, 0x63, - 0x72, 0x6f, 0x20, 0x47, 0x72, 0x69, 0x70, 0x20, 0x50, 0x72, 0x6f, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x53, 0x61, 0x6e, 0x77, 0x61, 0x20, 0x4f, 0x6e, 0x6c, - 0x69, 0x6e, 0x65, 0x20, 0x47, 0x72, 0x69, 0x70, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x33, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x53, 0x61, 0x6e, 0x77, 0x61, 0x20, 0x50, 0x6c, 0x61, 0x79, - 0x4f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x4d, 0x6f, 0x62, 0x69, 0x6c, - 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, - 0x61, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, - 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x6e, 0x77, 0x61, 0x20, 0x53, 0x6d, - 0x61, 0x72, 0x74, 0x20, 0x47, 0x72, 0x69, 0x70, 0x20, 0x49, 0x49, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x31, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x74, - 0x65, 0x63, 0x68, 0x69, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x63, 0x6f, - 0x72, 0x65, 0x20, 0x41, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x35, 0x32, 0x65, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x35, 0x37, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x63, 0x75, 0x66, - 0x20, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, - 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x20, 0x4d, 0x69, 0x6e, 0x69, - 0x20, 0x33, 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, 0x4d, 0x65, 0x67, 0x61, 0x20, 0x44, - 0x72, 0x69, 0x76, 0x65, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, 0x36, 0x42, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x39, 0x62, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, - 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, 0x53, 0x61, - 0x74, 0x75, 0x72, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x35, 0x2c, 0x79, 0x3a, 0x62, 0x36, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x37, 0x33, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, 0x53, 0x61, - 0x74, 0x75, 0x72, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x65, - 0x67, 0x61, 0x20, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x62, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x46, 0x58, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, - 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, - 0x38, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x53, 0x68, 0x6f, 0x67, 0x75, 0x6e, 0x20, 0x42, 0x72, 0x6f, 0x73, 0x20, - 0x43, 0x68, 0x61, 0x6d, 0x65, 0x6c, 0x65, 0x6f, 0x6e, 0x20, 0x58, 0x31, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, - 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x63, 0x31, 0x65, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, - 0x6e, 0x61, 0x6b, 0x65, 0x42, 0x79, 0x74, 0x65, 0x20, 0x34, 0x53, 0x20, - 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x31, 0x39, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, - 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, - 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x39, 0x36, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x4e, 0x45, 0x53, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x35, 0x2c, 0x79, - 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x31, 0x37, 0x30, - 0x30, 0x30, 0x30, 0x39, 0x64, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x4e, 0x45, 0x53, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, - 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x62, 0x32, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x4e, 0x45, 0x53, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, - 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x31, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x36, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, - 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, - 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x62, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x6f, 0x6e, 0x79, 0x20, - 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, - 0x50, 0x6f, 0x72, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x53, 0x70, 0x65, 0x65, 0x64, 0x6c, 0x69, 0x6e, - 0x6b, 0x20, 0x36, 0x35, 0x35, 0x35, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x61, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x70, 0x65, - 0x65, 0x64, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x36, 0x35, 0x36, 0x36, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, - 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x53, 0x70, 0x65, 0x65, 0x64, 0x6c, 0x69, 0x6e, 0x6b, - 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x65, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, - 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, - 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x53, 0x70, 0x65, 0x65, 0x64, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x53, 0x74, - 0x72, 0x69, 0x6b, 0x65, 0x20, 0x46, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, - 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x39, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, - 0x70, 0x65, 0x65, 0x64, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x54, 0x6f, 0x72, - 0x69, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x31, 0x31, 0x38, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x61, 0x64, 0x69, 0x61, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x66, 0x63, 0x31, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, 0x56, 0x69, 0x72, 0x74, 0x75, - 0x61, 0x6c, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x31, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, 0x56, 0x69, 0x72, 0x74, 0x75, - 0x61, 0x6c, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x2d, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, - 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x20, 0x50, 0x6c, 0x61, 0x79, - 0x20, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x74, 0x65, 0x63, 0x68, 0x20, 0x50, - 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x39, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, - 0x72, 0x69, 0x65, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x32, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, - 0x69, 0x65, 0x73, 0x20, 0x46, 0x72, 0x65, 0x65, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x31, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, - 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, 0x74, 0x75, 0x73, 0x20, 0x44, 0x75, - 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, - 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, 0x74, - 0x75, 0x73, 0x20, 0x44, 0x75, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x31, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, - 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, 0x74, 0x75, - 0x73, 0x20, 0x44, 0x75, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x38, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, - 0x72, 0x69, 0x65, 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, 0x74, 0x75, 0x73, - 0x20, 0x58, 0x4c, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x63, 0x31, - 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x53, 0x54, 0x4b, 0x20, 0x37, 0x30, 0x32, 0x34, 0x58, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x38, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x72, 0x65, 0x65, 0x74, 0x20, - 0x46, 0x69, 0x67, 0x68, 0x74, 0x65, 0x72, 0x20, 0x46, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, 0x45, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x66, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x53, 0x75, 0x70, 0x65, 0x72, 0x20, 0x46, 0x61, 0x6d, 0x69, - 0x63, 0x6f, 0x6d, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, - 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x38, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x53, 0x75, 0x70, 0x65, 0x72, 0x20, 0x46, 0x61, 0x6d, 0x69, 0x63, 0x6f, - 0x6d, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x34, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x53, 0x75, 0x70, 0x65, 0x72, 0x20, 0x52, 0x61, 0x63, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x61, 0x37, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x77, 0x69, - 0x74, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x66, - 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x48, - 0x6f, 0x72, 0x69, 0x20, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, - 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x31, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, - 0x7a, 0x6d, 0x79, 0x20, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x20, 0x50, 0x43, - 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x62, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x31, - 0x36, 0x30, 0x30, 0x30, 0x4d, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x37, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x41, 0x43, 0x20, - 0x47, 0x45, 0x41, 0x52, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x34, 0x30, 0x61, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x61, 0x69, 0x74, - 0x6f, 0x20, 0x45, 0x67, 0x72, 0x65, 0x74, 0x20, 0x49, 0x49, 0x20, 0x4d, - 0x69, 0x6e, 0x69, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x2d, 0x61, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x38, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, 0x31, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x45, 0x20, - 0x4b, 0x69, 0x74, 0x74, 0x79, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x61, 0x31, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x65, 0x61, - 0x6d, 0x20, 0x35, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x35, 0x30, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x32, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x65, 0x63, 0x68, 0x6d, - 0x6f, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x20, 0x58, 0x36, 0x2d, 0x33, - 0x38, 0x56, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x61, 0x32, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x65, 0x63, 0x68, 0x6e, 0x6f, - 0x6c, 0x6f, 0x67, 0x79, 0x20, 0x49, 0x6e, 0x6e, 0x6f, 0x76, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x53, 0x32, 0x20, 0x41, 0x64, 0x61, 0x70, - 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x31, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x65, 0x6e, 0x63, 0x65, - 0x6e, 0x74, 0x20, 0x58, 0x69, 0x61, 0x6e, 0x79, 0x6f, 0x75, 0x20, 0x47, - 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x47, 0x5a, 0x2c, 0x61, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x39, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x54, 0x48, 0x45, 0x43, 0x36, 0x34, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x39, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x54, 0x48, 0x45, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x62, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, - 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x44, - 0x75, 0x61, 0x6c, 0x20, 0x41, 0x6e, 0x61, 0x6c, 0x6f, 0x67, 0x20, 0x34, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x33, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, - 0x73, 0x74, 0x65, 0x72, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x54, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x65, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, - 0x73, 0x74, 0x4d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x65, 0x53, 0x77, - 0x61, 0x70, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x38, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, - 0x74, 0x4d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x46, 0x65, 0x72, 0x72, - 0x61, 0x72, 0x69, 0x20, 0x31, 0x35, 0x30, 0x20, 0x50, 0x6c, 0x61, 0x79, - 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, - 0x74, 0x65, 0x72, 0x20, 0x46, 0x69, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, - 0x6d, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x50, 0x6f, 0x77, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x62, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, - 0x65, 0x72, 0x20, 0x46, 0x69, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x6d, - 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x4d, 0x61, 0x73, - 0x74, 0x65, 0x72, 0x20, 0x52, 0x75, 0x6e, 0x20, 0x4e, 0x20, 0x44, 0x72, - 0x69, 0x76, 0x65, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, - 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x4d, 0x61, 0x73, - 0x74, 0x65, 0x72, 0x20, 0x52, 0x75, 0x6e, 0x20, 0x4e, 0x20, 0x44, 0x72, - 0x69, 0x76, 0x65, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x38, 0x63, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x75, 0x6e, 0x64, 0x65, - 0x72, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x36, 0x36, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x69, 0x67, 0x65, - 0x72, 0x47, 0x61, 0x6d, 0x65, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x36, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x38, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x54, 0x69, 0x67, 0x65, 0x72, 0x47, 0x61, 0x6d, 0x65, 0x20, 0x50, - 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x4d, 0x69, 0x6e, 0x69, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x37, 0x31, 0x64, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x54, 0x6f, 0x6d, 0x65, 0x65, 0x20, 0x4e, 0x45, 0x53, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, - 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x37, 0x31, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x6f, 0x6d, 0x65, - 0x65, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, - 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, - 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x50, 0x53, - 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x54, 0x72, 0x6f, 0x6e, 0x73, 0x6d, 0x61, 0x72, 0x74, 0x2c, - 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x66, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x63, 0x35, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x54, 0x72, 0x75, 0x73, 0x74, 0x20, 0x47, 0x61, 0x6d, - 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x38, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x72, 0x75, 0x73, 0x74, 0x20, - 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x37, 0x62, 0x36, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x57, 0x43, - 0x53, 0x20, 0x54, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x2d, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x2b, 0x61, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x31, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x77, - 0x69, 0x6e, 0x20, 0x53, 0x68, 0x6f, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, - 0x39, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x54, 0x77, 0x69, 0x6e, 0x53, 0x68, 0x6f, 0x63, 0x6b, 0x20, 0x50, 0x53, - 0x32, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x36, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x55, 0x6e, 0x69, 0x70, 0x6c, 0x61, 0x79, 0x20, - 0x55, 0x36, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x63, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x37, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x75, 0x52, 0x61, 0x67, - 0x65, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x62, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x55, 0x53, 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x53, 0x42, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, - 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, - 0x53, 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x33, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x53, 0x42, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x36, 0x36, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x53, 0x42, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x55, 0x53, 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x53, 0x42, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x62, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x63, 0x36, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x55, 0x53, 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x35, 0x30, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x35, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x53, 0x42, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x62, 0x64, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x55, 0x53, 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, - 0x66, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x33, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x55, 0x53, 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x53, 0x42, 0x20, 0x56, 0x69, - 0x62, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x4a, 0x6f, 0x79, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x61, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x56, 0x65, 0x6e, 0x6f, - 0x6d, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x62, - 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x56, 0x65, 0x6e, 0x6f, 0x6d, 0x20, 0x41, 0x72, 0x63, - 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x56, 0x69, 0x63, 0x74, 0x72, - 0x69, 0x78, 0x20, 0x50, 0x53, 0x34, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x46, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x37, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x56, 0x69, 0x63, 0x74, 0x72, 0x69, 0x78, 0x20, - 0x50, 0x53, 0x34, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x46, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x34, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, - 0x62, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x76, 0x4a, 0x6f, 0x79, 0x20, 0x44, 0x65, 0x76, 0x69, - 0x63, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x35, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x34, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x61, 0x62, 0x35, 0x37, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x57, 0x61, 0x72, 0x72, 0x69, 0x6f, 0x72, 0x20, 0x4a, 0x6f, 0x79, 0x70, - 0x61, 0x64, 0x20, 0x4a, 0x53, 0x30, 0x38, 0x33, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, - 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x57, 0x69, 0x69, 0x20, 0x55, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, - 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, - 0x36, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x57, 0x69, 0x6c, - 0x64, 0x63, 0x61, 0x74, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x34, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x57, 0x6f, 0x6c, 0x76, 0x65, 0x72, - 0x69, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x65, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, - 0x65, 0x66, 0x62, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, - 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, - 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x34, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, - 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x36, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, - 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x36, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, - 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x36, 0x62, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, - 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x34, - 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x30, 0x37, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2d, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x39, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, - 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, - 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x66, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, - 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x66, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, - 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, - 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x66, 0x64, 0x66, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, - 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, - 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x70, - 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x61, 0x31, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, - 0x57, 0x69, 0x72, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x52, 0x65, 0x63, - 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2d, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, - 0x78, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x69, 0x76, 0x65, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x2d, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x38, 0x38, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, - 0x7e, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x61, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x39, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x38, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, - 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x36, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, - 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x34, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x36, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x35, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, - 0x37, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, 0x30, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, - 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, - 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x64, 0x31, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x64, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, - 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, - 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x65, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, - 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x33, 0x30, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x61, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2d, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x66, 0x66, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, - 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x2b, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2d, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, - 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, - 0x30, 0x61, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, - 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x33, 0x61, 0x35, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x61, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x65, 0x6f, 0x78, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x35, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x58, 0x65, 0x6f, 0x78, 0x20, 0x53, 0x4c, 0x36, 0x35, 0x35, - 0x36, 0x42, 0x4b, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x47, 0x65, 0x61, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x37, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x34, - 0x34, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x58, 0x69, 0x61, 0x6f, 0x6d, 0x69, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x37, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x33, 0x33, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x58, 0x69, 0x61, 0x6f, 0x6d, 0x69, 0x20, 0x58, 0x4d, 0x47, 0x50, - 0x30, 0x31, 0x59, 0x4d, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x62, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x36, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x58, 0x69, 0x61, 0x6f, 0x6d, 0x69, 0x20, 0x58, 0x4d, 0x47, 0x50, - 0x30, 0x31, 0x59, 0x4d, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x2b, 0x61, 0x32, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x2b, 0x61, 0x35, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x2d, - 0x61, 0x31, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x2d, - 0x61, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, - 0x0d, 0x0a, 0x78, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x2c, 0x58, 0x49, 0x6e, - 0x70, 0x75, 0x74, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x58, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x6f, - 0x72, 0x20, 0x44, 0x69, 0x67, 0x69, 0x74, 0x61, 0x6c, 0x20, 0x47, 0x61, - 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, - 0x37, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x66, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x5a, 0x44, 0x54, 0x20, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x5a, 0x65, 0x72, - 0x6f, 0x70, 0x6c, 0x75, 0x73, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x31, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x5a, 0x65, 0x72, 0x6f, 0x70, 0x6c, 0x75, 0x73, - 0x20, 0x50, 0x34, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, - 0x73, 0x2c, 0x0d, 0x0a, 0x0d, 0x0a, 0x23, 0x20, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x32, 0x20, 0x49, 0x6e, 0x20, 0x31, 0x20, 0x4a, 0x6f, - 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, - 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, - 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, - 0x44, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x20, 0x32, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x39, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x44, - 0x6f, 0x67, 0x62, 0x6f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x46, 0x43, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x46, - 0x43, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x35, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, - 0x65, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x32, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, - 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x32, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x35, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, - 0x65, 0x20, 0x53, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x53, 0x45, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, - 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x31, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, - 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, - 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, - 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, - 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, - 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x35, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x61, - 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, 0x53, - 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, - 0x61, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, - 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, - 0x45, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, - 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, - 0x4e, 0x45, 0x53, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, - 0x45, 0x53, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, - 0x53, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x35, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x33, 0x30, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x35, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x33, 0x30, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, - 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, - 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, - 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x33, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, - 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x38, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, - 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x53, 0x46, 0x43, 0x33, 0x30, 0x20, 0x4a, 0x6f, 0x79, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, - 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, - 0x53, 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, - 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x39, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, - 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, - 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x32, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, - 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, - 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, - 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, - 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, - 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, 0x6c, 0x75, 0x73, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, - 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, 0x6c, 0x75, 0x73, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x55, - 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x20, 0x57, 0x69, 0x72, 0x65, - 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, - 0x63, 0x31, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, - 0x65, 0x31, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, - 0x65, 0x32, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x55, - 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x20, 0x57, 0x69, 0x72, 0x65, - 0x6c, 0x65, 0x73, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x70, 0x61, - 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x70, 0x61, - 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x55, 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x20, 0x57, - 0x69, 0x72, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x32, 0x36, 0x2c, - 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x32, 0x33, 0x2c, - 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, - 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, - 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, - 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x33, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, - 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x39, 0x31, 0x39, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x39, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x6d, 0x61, 0x7a, - 0x6f, 0x6e, 0x20, 0x4c, 0x75, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, - 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x37, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x39, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x6d, 0x61, 0x7a, 0x6f, 0x6e, 0x20, - 0x4c, 0x75, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, - 0x73, 0x63, 0x31, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x37, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x41, 0x73, 0x74, 0x72, 0x6f, 0x20, 0x43, 0x69, 0x74, 0x79, - 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x41, 0x73, 0x74, 0x72, 0x6f, 0x20, 0x43, 0x69, - 0x74, 0x79, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, - 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x53, 0x55, 0x53, 0x20, 0x47, 0x61, - 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x53, 0x55, - 0x53, 0x20, 0x52, 0x4f, 0x47, 0x20, 0x4b, 0x75, 0x6e, 0x61, 0x69, 0x20, - 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, - 0x63, 0x31, 0x3a, 0x62, 0x34, 0x32, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, - 0x65, 0x31, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, - 0x32, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, - 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x41, 0x53, 0x55, 0x53, 0x20, 0x52, 0x4f, 0x47, 0x20, - 0x4b, 0x75, 0x6e, 0x61, 0x69, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x32, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x74, - 0x61, 0x72, 0x69, 0x20, 0x56, 0x43, 0x53, 0x20, 0x43, 0x6c, 0x61, 0x73, - 0x73, 0x69, 0x63, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x37, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, - 0x20, 0x56, 0x43, 0x53, 0x20, 0x4d, 0x6f, 0x64, 0x65, 0x72, 0x6e, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, - 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x38, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, - 0x44, 0x41, 0x20, 0x4d, 0x4f, 0x47, 0x41, 0x20, 0x58, 0x50, 0x35, 0x2d, - 0x58, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, - 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x62, 0x38, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, - 0x44, 0x41, 0x20, 0x4d, 0x4f, 0x47, 0x41, 0x20, 0x58, 0x50, 0x35, 0x2d, - 0x58, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x61, 0x37, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, - 0x44, 0x41, 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, - 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x30, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x20, - 0x4d, 0x61, 0x72, 0x73, 0x20, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, - 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x65, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x72, - 0x6f, 0x6f, 0x6b, 0x20, 0x4d, 0x61, 0x72, 0x73, 0x20, 0x50, 0x53, 0x34, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x62, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x43, 0x69, 0x64, 0x65, 0x6b, 0x6f, 0x20, 0x41, 0x4b, 0x30, - 0x38, 0x62, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, 0x31, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x65, 0x63, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, 0x74, 0x68, 0x75, 0x6c, - 0x68, 0x75, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x36, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x38, 0x30, - 0x30, 0x30, 0x30, 0x38, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x43, 0x79, 0x62, 0x65, 0x72, 0x20, 0x47, 0x61, 0x64, 0x67, 0x65, 0x74, - 0x20, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x66, 0x36, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, 0x79, 0x62, - 0x6f, 0x72, 0x67, 0x20, 0x56, 0x33, 0x20, 0x52, 0x75, 0x6d, 0x62, 0x6c, - 0x65, 0x20, 0x50, 0x61, 0x64, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2d, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x31, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x44, 0x75, 0x61, - 0x6c, 0x20, 0x42, 0x6f, 0x78, 0x20, 0x57, 0x69, 0x69, 0x20, 0x43, 0x6c, - 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, 0x6f, - 0x6d, 0x20, 0x4a, 0x43, 0x2d, 0x57, 0x30, 0x31, 0x55, 0x2c, 0x61, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x61, 0x63, - 0x65, 0x6f, 0x66, 0x66, 0x20, 0x50, 0x72, 0x65, 0x6d, 0x69, 0x65, 0x72, - 0x65, 0x20, 0x57, 0x69, 0x72, 0x65, 0x64, 0x20, 0x50, 0x72, 0x6f, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x66, - 0x6f, 0x72, 0x20, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, - 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x6c, 0x79, - 0x64, 0x69, 0x67, 0x69, 0x20, 0x56, 0x61, 0x64, 0x65, 0x72, 0x20, 0x32, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x35, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x70, 0x61, - 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x61, 0x64, - 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x61, 0x64, 0x64, - 0x6c, 0x65, 0x33, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, - 0x6c, 0x65, 0x34, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, - 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x6c, 0x79, 0x64, 0x69, 0x67, 0x69, - 0x20, 0x56, 0x61, 0x64, 0x65, 0x72, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, - 0x62, 0x32, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, - 0x35, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x33, 0x3a, 0x62, 0x31, - 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x34, 0x3a, 0x62, 0x31, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x32, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, - 0x6c, 0x79, 0x64, 0x69, 0x67, 0x69, 0x20, 0x56, 0x61, 0x64, 0x65, 0x72, - 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x61, 0x64, - 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x70, 0x61, 0x64, - 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x70, 0x61, 0x64, - 0x64, 0x6c, 0x65, 0x33, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x70, 0x61, 0x64, - 0x64, 0x6c, 0x65, 0x34, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x36, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, - 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x35, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x36, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x35, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x34, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x31, 0x36, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x38, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x33, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x38, 0x2c, - 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x30, 0x36, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, - 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x2d, 0x54, 0x33, 0x20, 0x32, 0x2e, - 0x30, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x66, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x73, - 0x74, 0x6f, 0x70, 0x20, 0x42, 0x42, 0x30, 0x37, 0x30, 0x20, 0x58, 0x33, - 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, - 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x37, 0x35, - 0x33, 0x32, 0x30, 0x34, 0x37, 0x36, 0x31, 0x36, 0x64, 0x36, 0x35, 0x37, - 0x30, 0x36, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, - 0x6d, 0x65, 0x53, 0x74, 0x6f, 0x70, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, - 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, - 0x74, 0x6f, 0x70, 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x75, 0x6e, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, - 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x74, 0x6f, 0x70, 0x20, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x66, 0x66, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x33, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x57, 0x61, 0x72, 0x65, 0x20, 0x50, - 0x43, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x20, 0x50, 0x61, - 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, 0x61, 0x76, 0x69, 0x73, - 0x20, 0x45, 0x6c, 0x69, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x20, - 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, 0x61, - 0x76, 0x69, 0x73, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x64, 0x20, - 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, 0x65, - 0x65, 0x6e, 0x41, 0x73, 0x69, 0x61, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, - 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, - 0x65, 0x72, 0x20, 0x33, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, - 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, - 0x61, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x34, 0x20, 0x50, 0x53, 0x33, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x35, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, - 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, - 0x72, 0x20, 0x34, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, - 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, - 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, - 0x6e, 0x64, 0x65, 0x72, 0x20, 0x34, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, - 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, - 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, - 0x20, 0x34, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, - 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, - 0x64, 0x65, 0x72, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, - 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, - 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, - 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x50, 0x53, - 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, - 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x20, - 0x4d, 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, - 0x69, 0x6e, 0x67, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x6d, 0x69, - 0x6e, 0x69, 0x20, 0x34, 0x20, 0x28, 0x50, 0x53, 0x33, 0x29, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, - 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, - 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, - 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x20, - 0x34, 0x20, 0x28, 0x50, 0x53, 0x34, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, - 0x20, 0x47, 0x65, 0x6d, 0x20, 0x50, 0x61, 0x64, 0x20, 0x33, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, - 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, 0x43, 0x20, 0x45, 0x6e, 0x67, - 0x69, 0x6e, 0x65, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, 0x6f, 0x6b, 0x6b, - 0x65, 0x6e, 0x20, 0x54, 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x6e, - 0x74, 0x20, 0x44, 0x58, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, - 0x30, 0x61, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, - 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, - 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, - 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x53, 0x77, - 0x69, 0x74, 0x63, 0x68, 0x20, 0x53, 0x70, 0x6c, 0x69, 0x74, 0x20, 0x50, - 0x61, 0x64, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x70, - 0x61, 0x64, 0x20, 0x34, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, - 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, - 0x6f, 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x34, 0x20, 0x50, 0x53, 0x34, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x46, - 0x50, 0x53, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x20, 0x34, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x65, 0x65, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x48, 0x6f, 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x4d, 0x69, 0x6e, 0x69, - 0x20, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, - 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x65, 0x30, 0x30, 0x30, 0x30, - 0x66, 0x66, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6b, 0x69, - 0x6e, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x65, - 0x39, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, - 0x4e, 0x36, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x69, 0x42, 0x75, 0x66, - 0x66, 0x61, 0x6c, 0x6f, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x66, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, - 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x20, 0x41, 0x78, 0x69, 0x73, - 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, - 0x72, 0x61, 0x63, 0x74, 0x20, 0x47, 0x6f, 0x50, 0x61, 0x64, 0x2c, 0x61, - 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x6f, - 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x4c, 0x29, 0x2c, 0x2b, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x2b, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x2d, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x2d, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, - 0x28, 0x52, 0x29, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, - 0x66, 0x30, 0x30, 0x30, 0x30, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x59, - 0x53, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, - 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x63, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, - 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x63, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x44, 0x75, 0x61, - 0x6c, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, - 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x63, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x44, 0x75, - 0x61, 0x6c, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x63, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x44, - 0x75, 0x61, 0x6c, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, - 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, - 0x46, 0x33, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, - 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, 0x35, 0x31, 0x30, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, - 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, - 0x46, 0x37, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, - 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, 0x37, 0x31, 0x30, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x38, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, - 0x65, 0x63, 0x68, 0x20, 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, 0x50, 0x61, - 0x64, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x7e, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, - 0x37, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, - 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x50, 0x53, 0x33, 0x20, 0x46, - 0x69, 0x67, 0x68, 0x74, 0x70, 0x61, 0x64, 0x20, 0x50, 0x72, 0x6f, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x33, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x50, - 0x53, 0x33, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x20, 0x54, 0x45, 0x20, 0x53, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x38, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x50, - 0x53, 0x34, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x70, 0x61, 0x64, 0x20, - 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x34, 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, - 0x74, 0x7a, 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, 0x45, 0x20, 0x53, 0x20, 0x50, - 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x72, 0x76, 0x6f, 0x20, - 0x47, 0x54, 0x2d, 0x30, 0x30, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, - 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, - 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x34, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x36, 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x36, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, - 0x33, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, - 0x20, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x41, 0x64, - 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x34, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x31, 0x36, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x38, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x33, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x38, 0x2c, - 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x31, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, - 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x47, 0x61, 0x6d, 0x65, - 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, - 0x32, 0x66, 0x30, 0x30, 0x30, 0x30, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, - 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x4d, 0x61, 0x67, 0x69, - 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x32, - 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, - 0x4d, 0x61, 0x67, 0x69, 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x61, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, - 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x4d, 0x61, 0x67, 0x69, - 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, - 0x61, 0x73, 0x68, 0x20, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x62, 0x32, 0x38, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, - 0x33, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, - 0x32, 0x36, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x32, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x36, 0x2c, 0x79, 0x3a, - 0x62, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, - 0x30, 0x30, 0x30, 0x65, 0x38, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, - 0x6c, 0x61, 0x73, 0x68, 0x20, 0x57, 0x69, 0x69, 0x20, 0x43, 0x6c, 0x61, - 0x73, 0x73, 0x69, 0x63, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, - 0x73, 0x68, 0x20, 0x57, 0x69, 0x69, 0x20, 0x44, 0x6f, 0x6c, 0x70, 0x68, - 0x69, 0x6e, 0x42, 0x61, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x38, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x33, - 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x34, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x32, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, - 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x57, 0x69, 0x69, 0x20, - 0x55, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x38, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x33, 0x32, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x34, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x32, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x36, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x57, - 0x69, 0x69, 0x20, 0x55, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x41, 0x64, 0x61, - 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x3a, - 0x62, 0x38, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x33, 0x32, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x34, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x36, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, - 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, - 0x66, 0x74, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x53, 0x74, 0x72, 0x69, - 0x6b, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x7e, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, - 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, - 0x66, 0x74, 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, - 0x6f, 0x66, 0x74, 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, 0x64, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, - 0x73, 0x6f, 0x66, 0x74, 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, - 0x64, 0x65, 0x72, 0x20, 0x50, 0x6c, 0x75, 0x67, 0x20, 0x61, 0x6e, 0x64, - 0x20, 0x50, 0x6c, 0x61, 0x79, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, - 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x37, 0x31, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x6f, 0x67, - 0x61, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x61, 0x38, 0x39, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x4f, - 0x47, 0x41, 0x20, 0x58, 0x50, 0x35, 0x41, 0x20, 0x50, 0x6c, 0x75, 0x73, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, - 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x62, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x4f, 0x47, 0x41, 0x20, 0x58, 0x50, - 0x35, 0x41, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, - 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x37, 0x35, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4e, 0x65, 0x6f, 0x47, 0x65, 0x6f, 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x20, - 0x50, 0x41, 0x44, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x31, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x62, 0x34, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x45, 0x53, 0x20, - 0x32, 0x2d, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4e, 0x45, 0x58, 0x54, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, - 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x61, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, - 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, - 0x63, 0x68, 0x20, 0x43, 0x6f, 0x72, 0x65, 0x20, 0x50, 0x6c, 0x75, 0x73, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x61, - 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, - 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x41, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, - 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, - 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, - 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, - 0x66, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, - 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, - 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4e, 0x53, 0x4f, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x2b, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x38, 0x2c, 0x2b, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x37, 0x2c, 0x2d, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, - 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4e, 0x53, 0x4f, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x34, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, - 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x62, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4e, 0x79, 0x6b, 0x6f, 0x20, 0x41, 0x69, 0x72, 0x66, 0x6c, 0x6f, - 0x20, 0x45, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, 0x20, 0x50, 0x53, - 0x33, 0x20, 0x56, 0x65, 0x72, 0x73, 0x75, 0x73, 0x20, 0x46, 0x69, 0x67, - 0x68, 0x74, 0x69, 0x6e, 0x67, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, - 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x69, 0x72, 0x61, 0x6e, 0x68, 0x61, 0x20, 0x58, 0x74, 0x72, - 0x65, 0x6d, 0x65, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, - 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x36, 0x37, 0x30, 0x36, 0x30, 0x30, - 0x30, 0x30, 0x38, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, - 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x64, 0x61, - 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, - 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x37, - 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x20, 0x56, 0x69, 0x74, 0x61, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x64, 0x63, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, - 0x72, 0x41, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x45, 0x78, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x50, 0x53, 0x32, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, - 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, - 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x79, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, - 0x37, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x79, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, - 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x34, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x34, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, - 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x65, - 0x36, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x74, 0x6f, 0x75, 0x63, 0x68, 0x70, 0x61, 0x64, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x32, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x74, 0x6f, 0x75, 0x63, - 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, - 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, - 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x65, 0x36, 0x30, 0x63, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x74, 0x6f, 0x75, 0x63, 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x66, 0x32, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x74, 0x6f, 0x75, 0x63, - 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x50, 0x58, 0x4e, 0x20, 0x50, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, - 0x4d, 0x6f, 0x62, 0x69, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, 0x63, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, - 0x62, 0x61, 0x20, 0x44, 0x72, 0x61, 0x67, 0x6f, 0x6e, 0x20, 0x41, 0x72, - 0x63, 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x20, 0x28, 0x50, 0x53, 0x33, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, - 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, - 0x6e, 0x62, 0x61, 0x20, 0x44, 0x72, 0x6f, 0x6e, 0x65, 0x20, 0x41, 0x72, - 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, - 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x38, 0x39, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x4f, 0x6e, 0x7a, 0x61, 0x20, - 0x54, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, - 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, - 0x61, 0x7a, 0x65, 0x72, 0x20, 0x50, 0x61, 0x6e, 0x74, 0x68, 0x65, 0x72, - 0x61, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, - 0x20, 0x50, 0x61, 0x6e, 0x74, 0x68, 0x65, 0x72, 0x61, 0x20, 0x50, 0x53, - 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, - 0x69, 0x6a, 0x75, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, - 0x52, 0x61, 0x69, 0x6a, 0x75, 0x20, 0x4d, 0x6f, 0x62, 0x69, 0x6c, 0x65, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, - 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, - 0x61, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x69, 0x67, - 0x68, 0x74, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, - 0x72, 0x20, 0x53, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x36, 0x33, 0x61, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, - 0x65, 0x72, 0x20, 0x53, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x61, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, - 0x7a, 0x65, 0x72, 0x20, 0x57, 0x69, 0x6c, 0x64, 0x63, 0x61, 0x74, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x32, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x64, 0x67, - 0x65, 0x61, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x20, - 0x42, 0x69, 0x74, 0x20, 0x53, 0x65, 0x67, 0x61, 0x20, 0x47, 0x65, 0x6e, - 0x65, 0x73, 0x69, 0x73, 0x20, 0x36, 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, - 0x32, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x34, 0x37, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x52, 0x65, 0x74, 0x72, 0x6f, 0x20, 0x42, 0x69, 0x74, 0x20, 0x53, 0x65, - 0x67, 0x61, 0x20, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, - 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, - 0x61, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x78, - 0x3a, 0x62, 0x36, 0x2c, 0x79, 0x3a, 0x62, 0x38, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, - 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x52, 0x65, 0x74, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, - 0x74, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, - 0x6f, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, - 0x61, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, - 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, - 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, - 0x6f, 0x55, 0x53, 0x42, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x52, 0x65, 0x74, - 0x72, 0x6f, 0x50, 0x6f, 0x72, 0x74, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x62, 0x38, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x62, 0x39, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x37, 0x2c, 0x62, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x32, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x34, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x76, 0x6f, 0x6c, 0x75, 0x74, 0x69, - 0x6f, 0x6e, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x76, 0x6f, - 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x33, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x30, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x52, 0x69, 0x69, 0x20, 0x52, 0x4b, 0x37, 0x30, 0x37, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x79, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x66, 0x65, 0x66, 0x61, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, - 0x63, 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, 0x50, 0x53, 0x33, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, 0x63, - 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, 0x53, 0x77, 0x69, 0x74, - 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x62, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x6d, 0x73, 0x75, 0x6e, - 0x67, 0x20, 0x45, 0x49, 0x47, 0x50, 0x32, 0x30, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, - 0x78, 0x3a, 0x62, 0x37, 0x2c, 0x79, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x33, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x53, 0x61, 0x6e, 0x77, 0x61, 0x20, 0x50, 0x6c, 0x61, - 0x79, 0x4f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x4d, 0x6f, 0x62, 0x69, - 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x2d, 0x61, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, 0x47, - 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, - 0x33, 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, - 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x38, 0x31, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x36, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, - 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x61, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, 0x53, 0x61, - 0x74, 0x75, 0x72, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x35, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x61, 0x62, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x53, 0x46, 0x43, 0x33, 0x30, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x52, 0x65, 0x74, 0x72, - 0x6f, 0x50, 0x6f, 0x72, 0x74, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x61, - 0x30, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x53, 0x6f, 0x6e, 0x79, 0x20, 0x44, 0x75, 0x61, - 0x6c, 0x53, 0x68, 0x6f, 0x63, 0x6b, 0x20, 0x34, 0x20, 0x41, 0x64, 0x61, - 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x6f, 0x6e, 0x79, - 0x20, 0x44, 0x75, 0x61, 0x6c, 0x53, 0x68, 0x6f, 0x63, 0x6b, 0x20, 0x34, - 0x20, 0x56, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x31, 0x31, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x61, 0x64, 0x69, - 0x61, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, - 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, 0x56, 0x69, 0x72, 0x74, 0x75, - 0x61, 0x6c, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, - 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x4e, 0x69, 0x6d, - 0x62, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x39, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x7e, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, - 0x69, 0x65, 0x73, 0x20, 0x4e, 0x69, 0x6d, 0x62, 0x75, 0x73, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x38, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x31, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, - 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x4e, - 0x69, 0x6d, 0x62, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, - 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x7e, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x7e, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x38, 0x34, 0x39, 0x34, 0x34, 0x32, - 0x30, 0x34, 0x34, 0x36, 0x35, 0x37, 0x36, 0x36, 0x39, 0x36, 0x33, 0x36, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, - 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x4e, 0x69, 0x6d, 0x62, 0x75, 0x73, - 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x7e, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x65, 0x36, 0x39, 0x36, 0x64, 0x36, - 0x32, 0x37, 0x35, 0x37, 0x33, 0x32, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, - 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x4e, 0x69, 0x6d, 0x62, 0x75, 0x73, - 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x7e, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, - 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, 0x74, 0x75, - 0x73, 0x20, 0x44, 0x75, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x31, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, - 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, 0x74, 0x75, 0x73, 0x20, 0x44, 0x75, - 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, 0x31, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, - 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x53, 0x74, - 0x72, 0x61, 0x74, 0x75, 0x73, 0x20, 0x58, 0x4c, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, - 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x53, 0x74, 0x72, - 0x61, 0x74, 0x75, 0x73, 0x20, 0x58, 0x4c, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x7e, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x77, 0x69, 0x74, - 0x63, 0x68, 0x20, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, 0x61, 0x64, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x35, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x32, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x53, 0x5a, 0x4d, 0x59, 0x20, 0x50, 0x6f, 0x77, - 0x65, 0x72, 0x20, 0x50, 0x43, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, - 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x63, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x54, 0x47, 0x5a, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, - 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x39, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x54, 0x48, 0x45, 0x43, 0x36, 0x34, 0x20, 0x4a, 0x6f, 0x79, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x39, 0x31, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x54, 0x48, 0x45, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x62, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, - 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, - 0x44, 0x75, 0x61, 0x6c, 0x20, 0x41, 0x6e, 0x61, 0x6c, 0x6f, 0x67, 0x20, - 0x33, 0x2e, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x65, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, - 0x73, 0x74, 0x4d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x65, 0x53, 0x77, - 0x61, 0x70, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, - 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x46, 0x69, 0x72, - 0x65, 0x73, 0x74, 0x6f, 0x72, 0x6d, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, - 0x50, 0x6f, 0x77, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, - 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x37, 0x31, 0x64, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x6f, 0x6d, 0x65, 0x65, 0x20, 0x4e, - 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, - 0x61, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, - 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x62, 0x64, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x54, 0x6f, 0x6d, 0x65, 0x65, 0x20, 0x52, 0x65, 0x74, 0x72, 0x6f, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x64, 0x31, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x64, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x6f, - 0x6d, 0x65, 0x65, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x37, 0x31, 0x64, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x6f, 0x6d, 0x65, 0x65, 0x20, - 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x66, 0x31, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x63, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x72, - 0x75, 0x73, 0x74, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, - 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, - 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x54, 0x77, 0x69, 0x6e, 0x20, 0x55, 0x53, 0x42, 0x20, 0x4a, - 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x34, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x32, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x36, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, - 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x36, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x62, 0x65, 0x72, 0x77, 0x69, 0x74, - 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x36, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x6e, 0x69, 0x70, 0x6c, - 0x61, 0x79, 0x20, 0x55, 0x36, 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, 0x62, - 0x3a, 0x62, 0x36, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x35, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x33, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x33, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x32, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, - 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x56, 0x69, 0x63, 0x74, 0x72, 0x69, - 0x78, 0x20, 0x50, 0x53, 0x34, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x46, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x37, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x36, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x56, 0x69, 0x63, 0x74, 0x72, 0x69, 0x78, 0x20, - 0x50, 0x53, 0x34, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x46, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x37, 0x36, 0x39, 0x36, 0x39, 0x36, 0x64, 0x36, - 0x66, 0x37, 0x34, 0x36, 0x35, 0x32, 0x30, 0x32, 0x38, 0x33, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x2c, 0x57, 0x69, 0x69, 0x20, 0x52, 0x65, 0x6d, 0x6f, - 0x74, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x35, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x32, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, - 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x37, 0x36, 0x39, 0x36, 0x39, 0x36, 0x64, 0x36, 0x66, 0x37, 0x34, - 0x36, 0x35, 0x32, 0x30, 0x32, 0x38, 0x33, 0x31, 0x33, 0x38, 0x30, 0x30, - 0x2c, 0x57, 0x69, 0x69, 0x20, 0x55, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x36, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, - 0x62, 0x31, 0x38, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, - 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, - 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x64, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, - 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x41, 0x64, 0x61, 0x70, - 0x74, 0x69, 0x76, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x58, 0x62, 0x6f, 0x78, 0x20, 0x45, 0x6c, 0x69, 0x74, 0x65, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x53, 0x65, - 0x72, 0x69, 0x65, 0x73, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x33, - 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x62, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x62, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x62, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x35, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x64, 0x31, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x64, 0x64, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x65, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, - 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, - 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x33, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, - 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x65, 0x61, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, - 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, - 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x33, 0x61, 0x35, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x50, 0x6f, 0x77, 0x65, - 0x72, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, - 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x62, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, - 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, - 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, - 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, - 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, - 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x35, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, - 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, - 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x33, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, - 0x69, 0x61, 0x6f, 0x4d, 0x69, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x36, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x5a, 0x65, 0x72, - 0x6f, 0x70, 0x6c, 0x75, 0x73, 0x20, 0x50, 0x34, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, - 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x65, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x5a, - 0x65, 0x72, 0x6f, 0x70, 0x6c, 0x75, 0x73, 0x20, 0x50, 0x34, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, - 0x58, 0x2c, 0x0d, 0x0a, 0x0d, 0x0a, 0x23, 0x20, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, - 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, - 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x44, 0x6f, - 0x67, 0x62, 0x6f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x46, 0x43, 0x33, - 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x46, 0x43, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x46, - 0x43, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, - 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x35, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, - 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x32, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x35, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, - 0x65, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, - 0x4c, 0x69, 0x74, 0x65, 0x20, 0x53, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x53, 0x45, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, - 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x35, 0x31, 0x30, 0x36, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, - 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, - 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x20, 0x50, - 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x35, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, - 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, - 0x45, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x4e, 0x45, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x38, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, - 0x45, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x38, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, 0x53, 0x33, - 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, 0x53, 0x33, 0x30, 0x20, 0x50, 0x72, - 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, - 0x4e, 0x45, 0x53, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x38, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, 0x53, 0x33, - 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x50, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, - 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x33, - 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, - 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, - 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, - 0x72, 0x6f, 0x20, 0x32, 0x20, 0x57, 0x69, 0x72, 0x65, 0x64, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x20, 0x57, 0x69, 0x72, 0x65, - 0x64, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, - 0x20, 0x32, 0x20, 0x57, 0x69, 0x72, 0x65, 0x64, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, - 0x58, 0x62, 0x6f, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, - 0x20, 0x32, 0x20, 0x57, 0x69, 0x72, 0x65, 0x64, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, - 0x58, 0x62, 0x6f, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, - 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, - 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x33, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, - 0x69, 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, - 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x38, 0x36, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x53, 0x46, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, 0x33, 0x30, - 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x32, 0x61, 0x62, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, - 0x53, 0x46, 0x43, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x61, 0x62, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, 0x43, 0x33, - 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x61, 0x62, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, 0x43, 0x33, 0x30, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x53, 0x46, 0x43, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, - 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, - 0x53, 0x46, 0x43, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x35, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, - 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, - 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, - 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, - 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, - 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, - 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, - 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, - 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x32, - 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, - 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, - 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, - 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, - 0x53, 0x4e, 0x45, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, - 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x39, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, - 0x32, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, - 0x44, 0x6f, 0x20, 0x55, 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x20, - 0x57, 0x69, 0x72, 0x65, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x70, - 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x70, - 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, - 0x55, 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x20, 0x57, 0x69, 0x72, - 0x65, 0x6c, 0x65, 0x73, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x55, 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, - 0x20, 0x57, 0x69, 0x72, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, - 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, - 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x55, 0x6c, 0x74, 0x69, 0x6d, 0x61, - 0x74, 0x65, 0x20, 0x57, 0x69, 0x72, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, - 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, - 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, - 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, - 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, - 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, - 0x6e, 0x65, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x58, 0x62, 0x6f, 0x78, - 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, - 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x61, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, - 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x5a, 0x65, - 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, - 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x33, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, - 0x44, 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, - 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, - 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x31, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x35, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x63, - 0x72, 0x75, 0x78, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, - 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x33, 0x39, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, - 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x50, 0x72, 0x69, - 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x33, 0x39, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, - 0x20, 0x50, 0x72, 0x69, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x30, 0x34, - 0x38, 0x2d, 0x30, 0x30, 0x37, 0x2d, 0x4e, 0x41, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, - 0x6c, 0x6f, 0x77, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x66, 0x74, - 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, - 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x41, 0x6b, 0x69, 0x73, 0x68, 0x6f, 0x70, 0x20, 0x43, 0x75, 0x73, 0x74, - 0x6f, 0x6d, 0x73, 0x20, 0x50, 0x53, 0x33, 0x36, 0x30, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x63, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x41, 0x6c, 0x69, 0x65, 0x6e, 0x77, 0x61, 0x72, 0x65, 0x20, - 0x44, 0x75, 0x61, 0x6c, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, - 0x62, 0x6c, 0x65, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x20, 0x50, 0x6c, 0x61, - 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x39, 0x31, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x6d, 0x61, - 0x7a, 0x6f, 0x6e, 0x20, 0x46, 0x69, 0x72, 0x65, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x39, 0x31, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x39, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x6d, 0x61, 0x7a, 0x6f, - 0x6e, 0x20, 0x4c, 0x75, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, - 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x37, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x41, 0x6d, 0x61, 0x7a, 0x6f, 0x6e, 0x20, 0x4c, 0x75, 0x6e, 0x61, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x72, 0x63, 0x61, 0x64, - 0x65, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x20, 0x46, 0x33, 0x30, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x41, 0x73, 0x74, 0x72, 0x6f, 0x20, 0x43, 0x69, - 0x74, 0x79, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x41, 0x73, 0x74, 0x72, 0x6f, 0x20, 0x43, 0x69, 0x74, - 0x79, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x41, 0x53, 0x55, 0x53, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, - 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, - 0x53, 0x55, 0x53, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x53, 0x55, - 0x53, 0x20, 0x52, 0x4f, 0x47, 0x20, 0x4b, 0x75, 0x6e, 0x61, 0x69, 0x20, - 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, - 0x63, 0x31, 0x3a, 0x62, 0x33, 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, - 0x65, 0x31, 0x3a, 0x62, 0x35, 0x32, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, - 0x65, 0x32, 0x3a, 0x62, 0x35, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x37, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x41, 0x53, 0x55, 0x53, 0x20, 0x52, 0x4f, 0x47, 0x20, 0x4b, 0x75, - 0x6e, 0x61, 0x69, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x70, - 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x70, - 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, 0x20, 0x43, - 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, - 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, - 0x72, 0x69, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, - 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, - 0x74, 0x61, 0x72, 0x69, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, - 0x69, 0x63, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, 0x74, 0x61, - 0x72, 0x69, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, - 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x41, - 0x74, 0x61, 0x72, 0x69, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, 0x20, 0x56, 0x43, 0x53, 0x20, 0x4d, - 0x6f, 0x64, 0x65, 0x72, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x2b, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x62, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x42, 0x44, 0x41, 0x20, 0x4d, 0x4f, 0x47, 0x41, - 0x20, 0x58, 0x50, 0x35, 0x58, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, - 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x61, 0x37, 0x39, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x42, 0x44, 0x41, 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x69, 0x67, 0x68, - 0x74, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x32, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x37, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, 0x31, 0x20, 0x47, 0x43, 0x31, 0x30, - 0x31, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x20, 0x31, 0x2e, 0x30, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x33, 0x31, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x37, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, 0x31, 0x20, 0x47, - 0x43, 0x31, 0x30, 0x31, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x20, 0x31, 0x2e, 0x30, 0x33, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x65, - 0x31, 0x20, 0x47, 0x43, 0x31, 0x30, 0x31, 0x20, 0x58, 0x62, 0x6f, 0x78, - 0x20, 0x33, 0x36, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x62, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x64, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x42, 0x45, 0x49, 0x54, 0x4f, 0x4e, 0x47, 0x20, 0x41, 0x31, - 0x54, 0x32, 0x20, 0x42, 0x46, 0x4d, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x63, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, 0x45, 0x54, 0x4f, - 0x50, 0x20, 0x41, 0x58, 0x31, 0x20, 0x42, 0x46, 0x4d, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x63, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x31, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, - 0x65, 0x74, 0x6f, 0x70, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x42, 0x69, 0x67, 0x62, 0x65, 0x6e, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, - 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x65, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x42, - 0x72, 0x6f, 0x6f, 0x6b, 0x20, 0x4d, 0x61, 0x72, 0x73, 0x20, 0x50, 0x53, - 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x65, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x20, 0x4d, 0x61, 0x72, 0x73, 0x20, 0x50, - 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x66, 0x37, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x20, 0x55, 0x6e, 0x69, 0x76, 0x65, - 0x72, 0x73, 0x61, 0x6c, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, - 0x67, 0x20, 0x42, 0x6f, 0x61, 0x72, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x65, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x30, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, 0x69, 0x64, 0x65, 0x6b, 0x6f, 0x20, - 0x41, 0x4b, 0x30, 0x38, 0x62, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x33, 0x36, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, 0x6f, 0x6d, 0x70, 0x65, - 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, - 0x39, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x38, 0x38, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x43, 0x79, - 0x62, 0x65, 0x72, 0x20, 0x47, 0x61, 0x64, 0x67, 0x65, 0x74, 0x20, 0x47, - 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x32, 0x66, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x43, 0x79, 0x62, 0x6f, 0x72, 0x67, 0x20, 0x56, - 0x33, 0x20, 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x31, - 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x44, 0x75, - 0x61, 0x6c, 0x20, 0x42, 0x6f, 0x78, 0x20, 0x57, 0x69, 0x69, 0x20, 0x43, - 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x41, 0x20, - 0x53, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x31, 0x31, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x61, 0x73, - 0x79, 0x53, 0x4d, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, 0x30, - 0x30, 0x39, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x61, 0x73, 0x79, 0x53, 0x4d, - 0x58, 0x20, 0x45, 0x53, 0x4d, 0x2d, 0x39, 0x31, 0x30, 0x31, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x65, 0x63, - 0x6f, 0x6d, 0x20, 0x55, 0x33, 0x36, 0x31, 0x33, 0x4d, 0x2c, 0x61, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x65, - 0x63, 0x6f, 0x6d, 0x20, 0x57, 0x30, 0x31, 0x55, 0x2c, 0x61, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x37, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x6c, 0x69, 0x6d, 0x69, 0x6e, 0x61, - 0x74, 0x6f, 0x72, 0x20, 0x41, 0x66, 0x74, 0x65, 0x72, 0x53, 0x68, 0x6f, - 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x2d, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x30, 0x62, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, 0x4d, 0x53, 0x20, 0x50, - 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x53, - 0x32, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, - 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x35, 0x30, 0x33, 0x36, 0x38, 0x35, 0x32, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x69, 0x6e, 0x61, 0x6c, - 0x20, 0x46, 0x61, 0x6e, 0x74, 0x61, 0x73, 0x79, 0x20, 0x58, 0x49, 0x56, - 0x20, 0x4f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, 0x6c, 0x79, 0x64, - 0x69, 0x67, 0x69, 0x20, 0x56, 0x61, 0x64, 0x65, 0x72, 0x20, 0x32, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, - 0x63, 0x31, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, - 0x65, 0x31, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, - 0x32, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x33, - 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x34, - 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x32, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x46, - 0x6c, 0x79, 0x64, 0x69, 0x67, 0x69, 0x20, 0x56, 0x61, 0x64, 0x65, 0x72, - 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x61, 0x64, - 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x70, 0x61, 0x64, - 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x70, 0x61, 0x64, - 0x64, 0x6c, 0x65, 0x33, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x70, 0x61, 0x64, - 0x64, 0x6c, 0x65, 0x34, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x35, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x46, 0x6c, 0x79, 0x64, 0x69, 0x67, 0x69, 0x20, 0x56, - 0x61, 0x64, 0x65, 0x72, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x61, - 0x64, 0x64, 0x6c, 0x65, 0x33, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x70, 0x61, - 0x64, 0x64, 0x6c, 0x65, 0x34, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x37, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, - 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, - 0x61, 0x6d, 0x65, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x35, 0x62, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x20, 0x47, - 0x33, 0x77, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x62, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x20, 0x47, 0x33, - 0x77, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x38, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x62, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, - 0x20, 0x47, 0x34, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, 0x64, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x62, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, - 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x20, 0x47, 0x34, 0x73, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x33, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, - 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x35, 0x36, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x47, 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x20, 0x54, 0x34, 0x77, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x30, 0x36, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, - 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x2d, 0x54, 0x33, 0x20, 0x32, 0x2e, - 0x30, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x37, 0x35, 0x33, 0x32, 0x30, 0x34, 0x37, 0x36, - 0x31, 0x36, 0x64, 0x36, 0x35, 0x37, 0x30, 0x36, 0x31, 0x36, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, 0x6d, 0x65, 0x53, 0x74, 0x6f, 0x70, - 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, - 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, - 0x6d, 0x65, 0x73, 0x74, 0x6f, 0x70, 0x20, 0x4c, 0x6f, 0x67, 0x69, 0x63, - 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, - 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x61, - 0x73, 0x69, 0x61, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, - 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x35, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x47, 0x65, 0x6e, 0x69, 0x75, 0x73, 0x20, 0x4d, 0x61, 0x78, 0x66, - 0x69, 0x72, 0x65, 0x20, 0x47, 0x72, 0x61, 0x6e, 0x64, 0x69, 0x61, 0x73, - 0x20, 0x31, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x31, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x62, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x4f, 0x2d, 0x41, 0x64, 0x76, 0x61, - 0x6e, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x62, - 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, - 0x4f, 0x2d, 0x41, 0x64, 0x76, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, - 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, - 0x62, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x47, 0x4f, 0x2d, 0x53, 0x75, 0x70, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x39, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x66, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x31, - 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x47, 0x6f, 0x6f, 0x64, 0x62, 0x65, 0x74, 0x74, 0x65, - 0x72, 0x62, 0x65, 0x73, 0x74, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, - 0x34, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x47, 0x50, 0x44, 0x20, 0x57, 0x69, 0x6e, 0x20, - 0x32, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x64, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, - 0x61, 0x76, 0x69, 0x73, 0x20, 0x45, 0x6c, 0x69, 0x6d, 0x69, 0x6e, 0x61, - 0x74, 0x6f, 0x72, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, - 0x61, 0x76, 0x69, 0x73, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x64, - 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, 0x65, 0x65, 0x6e, - 0x41, 0x73, 0x69, 0x61, 0x20, 0x45, 0x6c, 0x65, 0x63, 0x74, 0x72, 0x6f, - 0x6e, 0x69, 0x63, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x41, 0x73, - 0x69, 0x61, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x37, 0x35, 0x33, 0x32, 0x30, 0x36, 0x37, 0x36, 0x31, 0x36, 0x64, - 0x36, 0x35, 0x37, 0x30, 0x36, 0x31, 0x36, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x47, 0x53, 0x20, 0x67, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x66, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x33, 0x38, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x47, 0x54, 0x20, 0x56, 0x58, 0x32, 0x2c, 0x61, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x64, - 0x65, 0x30, 0x30, 0x30, 0x30, 0x65, 0x66, 0x62, 0x65, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x69, - 0x64, 0x72, 0x6f, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x72, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, 0x31, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x38, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x69, 0x74, 0x42, 0x6f, 0x78, - 0x20, 0x50, 0x53, 0x33, 0x20, 0x50, 0x43, 0x20, 0x41, 0x6e, 0x61, 0x6c, - 0x6f, 0x67, 0x20, 0x4d, 0x6f, 0x64, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x39, 0x31, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x30, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x4a, 0x43, 0x20, - 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x32, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x4a, 0x44, - 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x36, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, - 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x45, 0x44, - 0x47, 0x45, 0x20, 0x33, 0x30, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x2b, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, - 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, - 0x61, 0x6e, 0x64, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, - 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, - 0x6e, 0x64, 0x65, 0x72, 0x20, 0x34, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, - 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, - 0x6e, 0x64, 0x65, 0x72, 0x20, 0x34, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, - 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, - 0x6e, 0x64, 0x65, 0x72, 0x20, 0x4f, 0x43, 0x54, 0x41, 0x20, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, - 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, - 0x64, 0x65, 0x72, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, - 0x30, 0x30, 0x38, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, - 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, - 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, - 0x33, 0x36, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x33, 0x37, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, - 0x74, 0x69, 0x6e, 0x67, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x4d, - 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, - 0x30, 0x30, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, - 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x53, 0x74, 0x69, - 0x63, 0x6b, 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x20, 0x34, 0x20, 0x28, 0x50, - 0x53, 0x33, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, - 0x6e, 0x67, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x6d, 0x69, 0x6e, - 0x69, 0x20, 0x34, 0x20, 0x28, 0x50, 0x53, 0x34, 0x29, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, - 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x33, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x66, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x33, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x56, 0x58, 0x2c, - 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x47, 0x65, - 0x6d, 0x20, 0x50, 0x61, 0x64, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x66, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x33, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, - 0x50, 0x61, 0x64, 0x20, 0x45, 0x58, 0x20, 0x54, 0x75, 0x72, 0x62, 0x6f, - 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, 0x43, 0x20, 0x45, 0x6e, 0x67, 0x69, - 0x6e, 0x65, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, - 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, - 0x6f, 0x72, 0x69, 0x20, 0x50, 0x6f, 0x6b, 0x6b, 0x65, 0x6e, 0x20, 0x54, - 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x44, 0x58, - 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, - 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x61, 0x61, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, - 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, - 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, - 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, - 0x50, 0x72, 0x6f, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, - 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, - 0x6f, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, - 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, - 0x20, 0x50, 0x72, 0x6f, 0x20, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, - 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, - 0x72, 0x6f, 0x20, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x52, 0x65, 0x61, - 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x50, 0x72, 0x6f, - 0x20, 0x45, 0x58, 0x53, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, - 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, - 0x72, 0x69, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x53, 0x70, - 0x6c, 0x69, 0x74, 0x20, 0x50, 0x61, 0x64, 0x20, 0x50, 0x72, 0x6f, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, - 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, - 0x69, 0x70, 0x61, 0x64, 0x20, 0x34, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, - 0x66, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, - 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x34, 0x20, 0x50, 0x53, 0x34, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, - 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x65, 0x65, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, - 0x6f, 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, - 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x36, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x4f, 0x6e, 0x65, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, - 0x66, 0x30, 0x30, 0x30, 0x30, 0x63, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, - 0x72, 0x69, 0x70, 0x61, 0x64, 0x20, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x66, 0x30, 0x30, - 0x30, 0x30, 0x66, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x70, - 0x61, 0x64, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, 0x72, - 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x34, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x66, 0x37, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x48, 0x75, 0x69, 0x4a, 0x69, 0x61, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x43, - 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x34, 0x32, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, - 0x41, 0x64, 0x6d, 0x69, 0x72, 0x61, 0x6c, 0x20, 0x4e, 0x36, 0x34, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x2b, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x2b, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x2d, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x38, 0x2c, 0x2d, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x34, 0x32, 0x65, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x62, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x48, 0x79, 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x4e, 0x36, - 0x34, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x65, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x61, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x79, 0x70, 0x65, - 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x54, 0x72, 0x6f, 0x6f, 0x70, 0x65, 0x72, - 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, - 0x32, 0x65, 0x30, 0x30, 0x30, 0x30, 0x38, 0x38, 0x31, 0x36, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, - 0x79, 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x58, 0x39, 0x31, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x64, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x79, 0x70, - 0x65, 0x72, 0x58, 0x20, 0x43, 0x6c, 0x75, 0x74, 0x63, 0x68, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, - 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x69, 0x42, 0x75, 0x66, 0x66, 0x61, 0x6c, 0x6f, 0x20, 0x53, 0x4e, 0x45, - 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x39, 0x36, 0x34, 0x37, - 0x32, 0x36, 0x66, 0x36, 0x39, 0x36, 0x34, 0x33, 0x61, 0x36, 0x33, 0x36, - 0x66, 0x36, 0x65, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x69, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x63, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x35, 0x30, 0x37, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x35, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6d, 0x70, 0x61, 0x63, 0x74, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x49, 0x4d, 0x53, 0x20, 0x50, 0x43, 0x55, 0x30, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, - 0x65, 0x72, 0x41, 0x63, 0x74, 0x20, 0x41, 0x78, 0x69, 0x73, 0x50, 0x61, - 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x65, 0x66, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x20, - 0x41, 0x78, 0x69, 0x73, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, - 0x65, 0x72, 0x41, 0x63, 0x74, 0x20, 0x47, 0x6f, 0x50, 0x61, 0x64, 0x2c, - 0x61, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x61, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, - 0x72, 0x41, 0x63, 0x74, 0x20, 0x48, 0x61, 0x6d, 0x6d, 0x65, 0x72, 0x48, - 0x65, 0x61, 0x64, 0x20, 0x46, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, - 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x39, 0x31, 0x39, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x62, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x70, 0x65, 0x67, - 0x61, 0x20, 0x50, 0x47, 0x20, 0x39, 0x30, 0x36, 0x39, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x36, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, - 0x33, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x37, 0x35, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x49, 0x70, 0x65, 0x67, 0x61, 0x20, 0x50, 0x47, 0x20, 0x39, 0x30, 0x39, - 0x39, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x39, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x62, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x49, 0x70, 0x65, 0x67, 0x61, 0x20, 0x50, 0x47, 0x39, - 0x30, 0x39, 0x39, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x39, 0x31, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x49, 0x70, 0x65, 0x67, 0x61, - 0x20, 0x50, 0x47, 0x39, 0x31, 0x31, 0x38, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, - 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, - 0x65, 0x73, 0x73, 0x20, 0x54, 0x65, 0x63, 0x68, 0x20, 0x44, 0x75, 0x61, - 0x6c, 0x20, 0x41, 0x6e, 0x61, 0x6c, 0x6f, 0x67, 0x20, 0x52, 0x75, 0x6d, - 0x62, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x62, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x65, 0x73, 0x73, 0x20, 0x54, 0x65, - 0x63, 0x68, 0x20, 0x47, 0x47, 0x45, 0x39, 0x30, 0x39, 0x20, 0x50, 0x43, - 0x20, 0x52, 0x65, 0x63, 0x6f, 0x69, 0x6c, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x61, 0x32, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x65, 0x73, - 0x73, 0x20, 0x54, 0x65, 0x63, 0x68, 0x6e, 0x6f, 0x6c, 0x6f, 0x67, 0x79, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, - 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x4c, 0x29, 0x2c, 0x2b, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x2b, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x2d, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x2d, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, - 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x4c, 0x29, 0x2c, 0x2b, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x2b, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x2d, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x2d, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x52, - 0x29, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, - 0x20, 0x28, 0x52, 0x29, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x64, 0x31, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x6f, 0x79, 0x70, - 0x61, 0x64, 0x20, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x20, 0x53, 0x68, 0x6f, - 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x59, 0x53, 0x20, 0x41, 0x64, 0x61, 0x70, - 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x34, 0x32, 0x66, 0x30, 0x30, 0x30, 0x30, 0x38, 0x61, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4a, 0x59, 0x53, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x34, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, - 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, - 0x67, 0x69, 0x63, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x64, 0x31, 0x63, 0x61, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x43, 0x68, - 0x69, 0x6c, 0x6c, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x63, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, - 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x72, 0x64, - 0x6c, 0x65, 0x73, 0x73, 0x20, 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, 0x50, - 0x61, 0x64, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x36, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, - 0x63, 0x68, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x41, 0x63, 0x74, 0x69, - 0x6f, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x36, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, - 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x64, 0x63, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, - 0x33, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x63, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, 0x35, - 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, - 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x63, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, 0x35, 0x31, - 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x63, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, - 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, 0x37, 0x31, 0x30, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x63, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, - 0x37, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x63, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x52, 0x75, - 0x6d, 0x62, 0x6c, 0x65, 0x50, 0x61, 0x64, 0x20, 0x32, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x63, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, - 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x57, 0x69, 0x6e, 0x67, - 0x4d, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x72, 0x64, 0x6c, 0x65, 0x73, 0x73, - 0x20, 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, 0x50, 0x61, 0x64, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x61, 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, - 0x68, 0x20, 0x57, 0x69, 0x6e, 0x67, 0x4d, 0x61, 0x6e, 0x20, 0x52, 0x75, - 0x6d, 0x62, 0x6c, 0x65, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x36, 0x35, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, - 0x61, 0x74, 0x7a, 0x20, 0x43, 0x54, 0x52, 0x4c, 0x52, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x35, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, - 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x70, - 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, - 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x70, 0x61, 0x64, - 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x30, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, - 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x70, 0x61, - 0x64, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x65, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x39, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, - 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x70, - 0x61, 0x64, 0x20, 0x53, 0x46, 0x78, 0x54, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, - 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x33, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, - 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, - 0x38, 0x30, 0x38, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, - 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, - 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, 0x33, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, - 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x46, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, 0x45, 0x20, 0x53, 0x20, - 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x38, 0x34, - 0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, - 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x54, - 0x45, 0x20, 0x53, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x38, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, - 0x61, 0x74, 0x7a, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x38, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, 0x43, - 0x61, 0x74, 0x7a, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, 0x37, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x36, 0x34, 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, 0x20, - 0x43, 0x61, 0x74, 0x7a, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, - 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x30, - 0x37, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x34, 0x37, 0x30, 0x30, 0x30, - 0x30, 0x39, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, - 0x64, 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, - 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x39, 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x64, - 0x20, 0x43, 0x61, 0x74, 0x7a, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, - 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, - 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, - 0x61, 0x6e, 0x74, 0x61, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x73, 0x68, 0x6f, - 0x63, 0x6b, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, - 0x73, 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, - 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, - 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x41, 0x64, 0x61, - 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x31, 0x38, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x47, 0x61, - 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, - 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x32, - 0x66, 0x30, 0x30, 0x30, 0x30, 0x37, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, - 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x4d, 0x61, 0x67, 0x69, 0x63, - 0x20, 0x4e, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x32, 0x31, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, - 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x4d, 0x61, 0x67, 0x69, - 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x61, 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, - 0x20, 0x4d, 0x61, 0x67, 0x69, 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, - 0x32, 0x66, 0x30, 0x30, 0x30, 0x30, 0x66, 0x37, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, - 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x4d, 0x61, 0x67, 0x69, - 0x63, 0x20, 0x53, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, - 0x68, 0x20, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x41, 0x64, 0x61, - 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x65, 0x38, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, - 0x57, 0x69, 0x69, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, - 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, - 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x57, - 0x69, 0x69, 0x20, 0x44, 0x6f, 0x6c, 0x70, 0x68, 0x69, 0x6e, 0x42, 0x61, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, - 0x6c, 0x61, 0x73, 0x68, 0x20, 0x57, 0x69, 0x69, 0x20, 0x55, 0x20, 0x50, - 0x72, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, - 0x35, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4d, 0x65, 0x67, 0x61, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x20, 0x4c, - 0x6f, 0x67, 0x69, 0x63, 0x20, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x35, 0x30, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x65, 0x67, 0x61, 0x20, - 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x20, 0x4c, 0x6f, 0x67, 0x69, 0x63, 0x20, - 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x6e, 0x74, 0x65, 0x6b, 0x20, - 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, - 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x44, 0x75, 0x61, 0x6c, - 0x20, 0x53, 0x74, 0x72, 0x69, 0x6b, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x33, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x7e, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, - 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, - 0x73, 0x6f, 0x66, 0x74, 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, - 0x64, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, - 0x66, 0x74, 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, - 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x20, - 0x46, 0x72, 0x65, 0x65, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x20, 0x50, 0x72, - 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x53, - 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x50, 0x6c, - 0x75, 0x67, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x35, 0x30, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x58, 0x62, - 0x6f, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, 0x30, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, - 0x58, 0x62, 0x6f, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, - 0x65, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, - 0x74, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, - 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x58, 0x62, 0x6f, - 0x78, 0x20, 0x33, 0x36, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x35, 0x36, 0x32, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, - 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, - 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, - 0x73, 0x6f, 0x66, 0x74, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, - 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x64, 0x31, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, - 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x58, 0x62, 0x6f, - 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x64, 0x31, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, - 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x64, 0x64, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, - 0x73, 0x6f, 0x66, 0x74, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, - 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x61, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, - 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x58, 0x62, 0x6f, - 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, - 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, - 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x65, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, - 0x66, 0x74, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, - 0x45, 0x6c, 0x69, 0x74, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, - 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x45, 0x6c, - 0x69, 0x74, 0x65, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, - 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x45, 0x6c, - 0x69, 0x74, 0x65, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x32, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, - 0x73, 0x6f, 0x66, 0x74, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, - 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4d, 0x69, 0x72, 0x6f, 0x6f, 0x66, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x64, 0x34, 0x66, 0x34, 0x33, 0x35, 0x35, 0x35, 0x34, 0x34, - 0x35, 0x32, 0x64, 0x33, 0x30, 0x33, 0x35, 0x33, 0x33, 0x35, 0x38, 0x30, - 0x30, 0x2c, 0x4d, 0x6f, 0x63, 0x75, 0x74, 0x65, 0x20, 0x30, 0x35, 0x33, - 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x65, 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x36, 0x65, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x62, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4d, 0x6f, 0x63, 0x75, 0x74, 0x65, 0x20, 0x30, 0x35, - 0x33, 0x58, 0x20, 0x4d, 0x35, 0x39, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x64, 0x34, - 0x66, 0x34, 0x33, 0x35, 0x35, 0x35, 0x34, 0x34, 0x35, 0x32, 0x64, 0x33, - 0x30, 0x33, 0x35, 0x33, 0x30, 0x35, 0x38, 0x30, 0x30, 0x2c, 0x4d, 0x6f, - 0x63, 0x75, 0x74, 0x65, 0x20, 0x30, 0x35, 0x34, 0x58, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x35, 0x38, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4d, 0x6f, 0x67, 0x61, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x61, 0x64, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x6f, 0x67, 0x61, 0x20, - 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x31, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x6f, 0x67, 0x61, 0x20, - 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x62, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x4f, 0x47, 0x41, 0x20, 0x58, 0x50, - 0x35, 0x41, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x61, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x4f, 0x47, - 0x41, 0x20, 0x58, 0x50, 0x35, 0x41, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x32, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x38, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4d, 0x4f, 0x47, 0x41, 0x20, 0x58, 0x50, 0x35, 0x58, 0x20, 0x50, - 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x36, 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x50, 0x38, 0x38, 0x36, 0x36, 0x20, - 0x53, 0x75, 0x70, 0x65, 0x72, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x42, - 0x6f, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, - 0x65, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x53, 0x49, 0x20, 0x47, 0x43, 0x32, 0x30, - 0x20, 0x56, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x61, 0x63, - 0x6f, 0x6e, 0x20, 0x41, 0x73, 0x79, 0x6d, 0x6d, 0x65, 0x74, 0x72, 0x69, - 0x63, 0x20, 0x57, 0x69, 0x72, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x50, - 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, - 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x63, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, - 0x61, 0x63, 0x6f, 0x6e, 0x20, 0x47, 0x43, 0x20, 0x34, 0x30, 0x30, 0x45, - 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x38, 0x35, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x36, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4e, 0x61, 0x63, 0x6f, 0x6e, 0x20, 0x47, 0x43, 0x2d, 0x31, 0x30, - 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, - 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, - 0x61, 0x74, 0x65, 0x63, 0x20, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, - 0x20, 0x50, 0x34, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x66, 0x31, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x65, 0x6f, 0x47, 0x65, 0x6f, 0x20, 0x50, - 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x39, 0x32, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x34, 0x37, 0x34, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4e, 0x65, 0x6f, 0x47, 0x65, 0x6f, 0x20, 0x58, 0x20, 0x41, 0x72, - 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x31, 0x38, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4e, 0x65, 0x78, 0x69, 0x6c, 0x75, 0x78, 0x20, 0x47, 0x61, 0x6d, - 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x38, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x45, 0x58, - 0x54, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x36, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x37, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, - 0x6f, 0x20, 0x33, 0x44, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, - 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x35, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x37, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x38, 0x30, - 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x47, - 0x61, 0x6d, 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x34, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x7e, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, - 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x36, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, - 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x43, 0x75, - 0x62, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x32, 0x7e, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x36, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x65, 0x36, 0x39, 0x36, 0x65, 0x37, 0x34, 0x36, - 0x35, 0x36, 0x65, 0x36, 0x34, 0x36, 0x66, 0x32, 0x30, 0x35, 0x33, 0x37, - 0x37, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, - 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6d, 0x62, - 0x69, 0x6e, 0x65, 0x64, 0x20, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, - 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x36, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, - 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x43, - 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x4a, 0x6f, 0x79, 0x2d, - 0x43, 0x6f, 0x6e, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, - 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, - 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, - 0x68, 0x20, 0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x4a, - 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x35, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x37, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, - 0x73, 0x63, 0x31, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x63, 0x36, 0x39, 0x36, 0x33, 0x32, 0x30, 0x35, 0x30, 0x37, 0x32, - 0x36, 0x66, 0x32, 0x30, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x30, 0x30, - 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, - 0x69, 0x74, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, - 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, - 0x69, 0x74, 0x63, 0x68, 0x20, 0x4c, 0x65, 0x66, 0x74, 0x20, 0x4a, 0x6f, - 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x36, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x30, 0x7e, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x79, - 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x33, 0x61, 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, - 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, - 0x6f, 0x77, 0x65, 0x72, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x31, 0x61, 0x37, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, - 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, 0x6f, 0x77, 0x65, - 0x72, 0x41, 0x20, 0x43, 0x6f, 0x72, 0x65, 0x20, 0x50, 0x6c, 0x75, 0x73, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x38, 0x30, 0x33, 0x2c, 0x4e, - 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, - 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, - 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, - 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, - 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, - 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, - 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, - 0x31, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, - 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, - 0x63, 0x68, 0x20, 0x52, 0x69, 0x67, 0x68, 0x74, 0x20, 0x4a, 0x6f, 0x79, - 0x2d, 0x43, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x31, 0x7e, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x57, - 0x69, 0x69, 0x20, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, - 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x57, 0x69, 0x69, 0x20, 0x55, 0x20, - 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x38, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x6f, - 0x73, 0x74, 0x72, 0x6f, 0x6d, 0x6f, 0x20, 0x6e, 0x34, 0x35, 0x20, 0x44, - 0x75, 0x61, 0x6c, 0x20, 0x41, 0x6e, 0x61, 0x6c, 0x6f, 0x67, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x53, - 0x4f, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x62, 0x38, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x62, 0x37, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x32, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, - 0x63, 0x31, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x53, 0x4f, 0x20, 0x4e, 0x36, 0x34, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x2b, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x2b, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x38, 0x2c, 0x2d, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x39, 0x2c, 0x2d, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x37, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x53, - 0x4f, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x37, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x76, 0x30, 0x31, 0x2e, 0x30, - 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x37, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x76, 0x30, 0x31, 0x2e, 0x30, 0x34, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, - 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, - 0x59, 0x4b, 0x4f, 0x20, 0x43, 0x4f, 0x52, 0x45, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x31, - 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4f, 0x44, 0x52, 0x4f, - 0x49, 0x44, 0x20, 0x47, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x36, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4f, 0x44, - 0x52, 0x4f, 0x49, 0x44, 0x20, 0x47, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x64, 0x63, 0x32, - 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4f, 0x6e, 0x79, 0x78, 0x53, 0x6f, 0x66, 0x74, 0x20, 0x44, - 0x75, 0x61, 0x6c, 0x20, 0x4a, 0x6f, 0x79, 0x44, 0x69, 0x76, 0x69, 0x73, - 0x69, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x36, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4f, 0x55, 0x59, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x62, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, - 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4f, 0x55, 0x59, 0x41, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, - 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, 0x32, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4f, 0x55, 0x59, 0x41, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x31, - 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x61, 0x64, 0x69, - 0x78, 0x20, 0x52, 0x6f, 0x63, 0x6b, 0x66, 0x69, 0x72, 0x65, 0x20, 0x50, - 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x42, - 0x72, 0x69, 0x64, 0x67, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x31, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x31, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x43, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, - 0x65, 0x30, 0x30, 0x30, 0x30, 0x62, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, - 0x50, 0x20, 0x41, 0x66, 0x74, 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, - 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, - 0x62, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, 0x20, 0x41, 0x66, 0x74, - 0x65, 0x72, 0x67, 0x6c, 0x6f, 0x77, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, - 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, - 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x36, 0x34, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x50, 0x44, 0x50, 0x20, 0x42, 0x61, 0x74, 0x74, 0x6c, 0x65, 0x66, 0x69, - 0x65, 0x6c, 0x64, 0x20, 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, - 0x64, 0x37, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, 0x20, 0x42, 0x6c, 0x61, - 0x63, 0x6b, 0x20, 0x43, 0x61, 0x6d, 0x6f, 0x20, 0x57, 0x69, 0x72, 0x65, - 0x64, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, - 0x73, 0x20, 0x58, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, - 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, - 0x44, 0x50, 0x20, 0x45, 0x41, 0x20, 0x53, 0x70, 0x6f, 0x72, 0x74, 0x73, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, - 0x20, 0x46, 0x61, 0x63, 0x65, 0x6f, 0x66, 0x66, 0x20, 0x4e, 0x69, 0x6e, - 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, - 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, 0x20, 0x4b, 0x69, 0x6e, 0x67, 0x64, - 0x6f, 0x6d, 0x20, 0x48, 0x65, 0x61, 0x72, 0x74, 0x73, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, 0x20, 0x4e, 0x69, - 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, - 0x68, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x70, 0x61, 0x64, 0x20, 0x50, - 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x50, 0x44, 0x50, 0x20, 0x50, 0x53, 0x33, 0x20, 0x52, 0x6f, - 0x63, 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, - 0x20, 0x50, 0x53, 0x33, 0x20, 0x56, 0x65, 0x72, 0x73, 0x75, 0x73, 0x20, - 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e, 0x67, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x61, 0x64, 0x31, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x44, 0x50, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, - 0x30, 0x20, 0x56, 0x65, 0x72, 0x73, 0x75, 0x73, 0x20, 0x46, 0x69, 0x67, - 0x68, 0x74, 0x69, 0x6e, 0x67, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x61, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, - 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, - 0x30, 0x30, 0x30, 0x61, 0x37, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, 0x20, - 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x52, 0x61, 0x76, - 0x65, 0x6e, 0x20, 0x42, 0x6c, 0x61, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x44, 0x50, 0x20, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x36, 0x36, 0x36, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x37, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x64, 0x61, 0x30, 0x63, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, - 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x39, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, 0x66, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, - 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x41, 0x64, - 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x37, 0x31, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, - 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x56, 0x69, 0x74, 0x61, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, - 0x65, 0x72, 0x41, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x33, 0x61, 0x35, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x41, 0x20, 0x31, 0x34, 0x32, 0x38, - 0x31, 0x32, 0x34, 0x2d, 0x30, 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x41, 0x20, 0x46, - 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, - 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x61, 0x35, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, - 0x6f, 0x77, 0x65, 0x72, 0x41, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, 0x50, - 0x72, 0x6f, 0x20, 0x45, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, - 0x63, 0x61, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x41, 0x20, 0x50, 0x72, - 0x6f, 0x20, 0x45, 0x78, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x61, 0x35, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x41, 0x20, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x41, 0x20, - 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, - 0x72, 0x41, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x61, 0x35, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, 0x77, 0x65, - 0x72, 0x41, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, - 0x4d, 0x69, 0x6e, 0x69, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x64, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x41, 0x20, 0x58, 0x62, 0x6f, 0x78, - 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x53, 0x70, 0x65, 0x63, 0x74, 0x72, 0x61, - 0x20, 0x49, 0x6e, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x6f, - 0x77, 0x65, 0x72, 0x41, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, - 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x64, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x64, 0x32, 0x63, 0x61, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, - 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x34, 0x31, 0x33, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, - 0x53, 0x32, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x34, 0x31, 0x61, 0x30, 0x30, 0x30, 0x30, 0x33, 0x36, - 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, - 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x38, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x30, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x62, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, - 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x66, 0x31, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, - 0x37, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x79, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x31, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x79, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x30, 0x34, 0x63, 0x34, 0x31, 0x35, 0x39, 0x35, 0x33, 0x35, 0x34, - 0x34, 0x31, 0x35, 0x34, 0x34, 0x39, 0x34, 0x66, 0x34, 0x65, 0x30, 0x30, - 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x62, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, - 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x34, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x35, - 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, 0x62, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, - 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x34, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x34, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x38, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x63, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x63, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, - 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, - 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x34, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x34, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x34, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, - 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x65, 0x36, - 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x74, 0x6f, 0x75, 0x63, 0x68, 0x70, 0x61, 0x64, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x65, - 0x36, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x38, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x66, 0x32, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x74, 0x6f, 0x75, 0x63, 0x68, 0x70, - 0x61, 0x64, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x65, 0x36, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x74, 0x6f, 0x75, - 0x63, 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x65, 0x36, 0x30, 0x63, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, - 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, - 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x66, 0x32, 0x30, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x74, 0x6f, 0x75, 0x63, 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, - 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, 0x62, 0x61, 0x20, 0x41, 0x72, 0x63, - 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, - 0x32, 0x63, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, - 0x61, 0x6e, 0x62, 0x61, 0x20, 0x44, 0x72, 0x61, 0x67, 0x6f, 0x6e, 0x20, - 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x20, 0x28, 0x50, 0x53, 0x33, 0x29, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, 0x63, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, - 0x62, 0x61, 0x20, 0x44, 0x72, 0x61, 0x67, 0x6f, 0x6e, 0x20, 0x41, 0x72, - 0x63, 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x20, 0x28, 0x50, 0x53, 0x34, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, 0x63, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, 0x62, 0x61, - 0x20, 0x44, 0x72, 0x6f, 0x6e, 0x65, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, - 0x65, 0x20, 0x50, 0x53, 0x34, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, - 0x62, 0x61, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, - 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, 0x63, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, 0x62, 0x61, 0x20, - 0x4f, 0x62, 0x73, 0x69, 0x64, 0x69, 0x61, 0x6e, 0x20, 0x41, 0x72, 0x63, - 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x20, 0x28, 0x50, 0x53, 0x33, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x32, 0x63, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x51, 0x61, 0x6e, 0x62, 0x61, 0x20, - 0x4f, 0x62, 0x73, 0x69, 0x64, 0x69, 0x61, 0x6e, 0x20, 0x41, 0x72, 0x63, - 0x61, 0x64, 0x65, 0x20, 0x4a, 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x20, 0x28, 0x50, 0x53, 0x34, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, - 0x74, 0x20, 0x34, 0x6e, 0x65, 0x73, 0x34, 0x73, 0x6e, 0x65, 0x73, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x34, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, - 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, - 0x74, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x4e, 0x45, 0x53, 0x20, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, - 0x65, 0x74, 0x20, 0x47, 0x43, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x4e, 0x36, - 0x34, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x38, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x39, 0x62, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x52, 0x61, 0x70, 0x68, 0x6e, 0x65, 0x74, 0x20, 0x47, 0x43, - 0x20, 0x61, 0x6e, 0x64, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x41, 0x64, 0x61, - 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, - 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, 0x31, 0x36, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x64, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, - 0x65, 0x72, 0x20, 0x4f, 0x6e, 0x7a, 0x61, 0x20, 0x43, 0x6c, 0x61, 0x73, - 0x73, 0x69, 0x63, 0x20, 0x45, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x50, - 0x61, 0x6e, 0x74, 0x68, 0x65, 0x72, 0x61, 0x20, 0x50, 0x53, 0x33, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, - 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, - 0x61, 0x7a, 0x65, 0x72, 0x20, 0x50, 0x61, 0x6e, 0x74, 0x68, 0x65, 0x72, - 0x61, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x50, - 0x61, 0x6e, 0x74, 0x68, 0x65, 0x72, 0x61, 0x20, 0x50, 0x53, 0x34, 0x20, - 0x45, 0x76, 0x6f, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, - 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, - 0x69, 0x6a, 0x75, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, 0x69, - 0x6a, 0x75, 0x20, 0x4d, 0x6f, 0x62, 0x69, 0x6c, 0x65, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x32, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, - 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, - 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, 0x69, 0x6a, 0x75, 0x20, 0x54, - 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x45, 0x64, - 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, - 0x61, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x53, 0x34, 0x20, 0x46, 0x69, 0x67, - 0x68, 0x74, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x39, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x66, 0x65, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x53, - 0x61, 0x62, 0x65, 0x72, 0x74, 0x6f, 0x6f, 0x74, 0x68, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x35, 0x64, 0x30, 0x30, 0x30, 0x30, 0x32, 0x34, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, - 0x20, 0x53, 0x61, 0x62, 0x65, 0x72, 0x74, 0x6f, 0x6f, 0x74, 0x68, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x64, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, - 0x65, 0x72, 0x20, 0x53, 0x61, 0x62, 0x65, 0x72, 0x74, 0x6f, 0x6f, 0x74, - 0x68, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, - 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, - 0x61, 0x7a, 0x65, 0x72, 0x20, 0x53, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x36, 0x33, 0x61, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, - 0x65, 0x72, 0x20, 0x53, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, - 0x20, 0x57, 0x69, 0x6c, 0x64, 0x63, 0x61, 0x74, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x31, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x62, 0x34, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x47, 0x61, 0x6d, 0x65, 0x20, 0x4a, - 0x6f, 0x79, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x38, 0x31, 0x31, 0x37, 0x30, 0x30, 0x30, 0x30, 0x39, 0x39, - 0x30, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x20, - 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, - 0x72, 0x6f, 0x50, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x35, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x32, 0x36, 0x35, 0x37, 0x34, 0x37, 0x32, 0x36, 0x66, 0x35, 0x33, 0x37, - 0x34, 0x36, 0x66, 0x36, 0x65, 0x36, 0x35, 0x33, 0x32, 0x30, 0x30, 0x2c, - 0x52, 0x65, 0x74, 0x72, 0x6f, 0x53, 0x74, 0x6f, 0x6e, 0x65, 0x20, 0x32, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x55, 0x53, 0x42, - 0x20, 0x4e, 0x36, 0x34, 0x20, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x50, 0x6f, - 0x72, 0x74, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, - 0x38, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x39, - 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x61, 0x3a, 0x62, 0x37, 0x2c, 0x62, 0x3a, 0x62, 0x36, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, 0x76, - 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x72, 0x6f, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x62, 0x31, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x64, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x65, - 0x76, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x72, 0x6f, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x20, - 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x52, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, 0x63, - 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, 0x50, 0x53, 0x33, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, - 0x65, 0x30, 0x30, 0x30, 0x30, 0x38, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, - 0x63, 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, 0x53, 0x77, 0x69, - 0x74, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, 0x30, 0x30, 0x30, 0x66, 0x65, 0x66, - 0x61, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x52, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, - 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x36, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x52, 0x6f, 0x63, 0x6b, 0x20, 0x43, - 0x61, 0x6e, 0x64, 0x79, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, - 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, - 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x32, 0x33, 0x66, 0x36, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, - 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x43, 0x79, 0x62, 0x6f, 0x72, 0x67, - 0x20, 0x56, 0x31, 0x20, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x31, 0x35, - 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, - 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, - 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x32, 0x32, 0x30, 0x2c, 0x61, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x63, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, - 0x65, 0x6b, 0x20, 0x50, 0x32, 0x35, 0x30, 0x30, 0x20, 0x46, 0x6f, 0x72, - 0x63, 0x65, 0x20, 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, 0x2c, 0x61, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, - 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, - 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x32, 0x39, 0x30, 0x30, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, - 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x38, 0x66, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, - 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x33, 0x32, 0x30, 0x30, 0x20, - 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x66, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, - 0x65, 0x6b, 0x20, 0x50, 0x33, 0x38, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, - 0x74, 0x65, 0x6b, 0x20, 0x50, 0x38, 0x38, 0x30, 0x2c, 0x61, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x31, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, 0x39, - 0x39, 0x30, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x41, 0x6e, 0x61, 0x6c, - 0x6f, 0x67, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x30, 0x66, 0x36, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x69, 0x74, 0x65, 0x6b, 0x20, 0x50, - 0x53, 0x32, 0x37, 0x30, 0x30, 0x20, 0x52, 0x75, 0x6d, 0x62, 0x6c, 0x65, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, - 0x38, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x62, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x53, 0x61, 0x6d, 0x73, 0x75, 0x6e, 0x67, 0x20, 0x45, 0x49, 0x47, 0x50, - 0x32, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x38, 0x31, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x53, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, - 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x61, 0x33, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, 0x47, 0x65, - 0x6e, 0x65, 0x73, 0x69, 0x73, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, 0x33, - 0x42, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x65, 0x67, - 0x61, 0x20, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, - 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, - 0x65, 0x67, 0x61, 0x20, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x61, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x65, 0x67, 0x61, 0x20, 0x53, 0x61, - 0x74, 0x75, 0x72, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, - 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x66, - 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x65, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, - 0x46, 0x43, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, - 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x32, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x68, 0x61, - 0x6e, 0x57, 0x61, 0x6e, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x66, 0x30, 0x32, 0x35, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x63, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x53, 0x68, 0x61, 0x6e, 0x77, 0x61, 0x6e, 0x20, 0x47, 0x69, - 0x6f, 0x74, 0x65, 0x63, 0x6b, 0x20, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x33, 0x32, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x37, 0x35, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x68, - 0x61, 0x6e, 0x77, 0x61, 0x6e, 0x20, 0x50, 0x53, 0x33, 0x20, 0x50, 0x43, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, - 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x53, 0x68, 0x61, 0x6e, 0x77, 0x61, 0x6e, 0x20, 0x50, 0x53, 0x33, 0x20, - 0x50, 0x43, 0x20, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x34, 0x31, 0x61, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x39, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x4c, 0x36, 0x35, 0x36, - 0x36, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, - 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x53, 0x6f, 0x6e, 0x79, 0x20, 0x44, 0x75, 0x61, 0x6c, - 0x53, 0x68, 0x6f, 0x63, 0x6b, 0x20, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x62, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x6f, 0x6e, 0x79, 0x20, - 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, - 0x50, 0x6f, 0x72, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x53, 0x6f, 0x6e, 0x79, 0x20, 0x50, 0x53, 0x32, 0x20, 0x70, - 0x61, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x53, 0x6d, 0x61, 0x72, - 0x74, 0x4a, 0x6f, 0x79, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x37, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x53, 0x70, 0x65, 0x65, 0x64, 0x6c, 0x69, 0x6e, 0x6b, 0x20, - 0x54, 0x6f, 0x72, 0x69, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x53, 0x70, 0x65, 0x65, 0x64, 0x4c, 0x69, 0x6e, 0x6b, - 0x20, 0x58, 0x65, 0x6f, 0x78, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x41, 0x6e, - 0x61, 0x6c, 0x6f, 0x67, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x31, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x53, 0x74, 0x61, 0x64, 0x69, 0x61, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x64, 0x31, 0x31, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x39, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x61, 0x64, 0x69, 0x61, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, - 0x6d, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x2b, 0x61, 0x35, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x2d, 0x61, 0x34, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, - 0x35, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, - 0x31, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, - 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, - 0x6d, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, - 0x62, 0x31, 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, - 0x79, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x32, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x32, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x62, 0x31, 0x39, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x32, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x37, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, - 0x36, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x34, 0x2c, 0x79, 0x3a, - 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x66, 0x63, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, - 0x6d, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x70, - 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x70, - 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, 0x44, - 0x65, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x3a, 0x62, - 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x78, 0x3a, 0x62, 0x35, 0x2c, 0x79, 0x3a, 0x62, 0x36, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x31, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, 0x56, 0x69, 0x72, 0x74, 0x75, - 0x61, 0x6c, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x65, 0x36, 0x39, 0x36, - 0x64, 0x36, 0x32, 0x37, 0x35, 0x37, 0x33, 0x32, 0x62, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, - 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x4e, 0x69, 0x6d, 0x62, - 0x75, 0x73, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x30, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x37, - 0x35, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, - 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, - 0x74, 0x75, 0x73, 0x20, 0x44, 0x75, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x38, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x31, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x37, 0x35, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, - 0x72, 0x69, 0x65, 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, 0x74, 0x75, 0x73, - 0x20, 0x44, 0x75, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x33, 0x31, 0x31, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x62, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, - 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, 0x74, 0x75, 0x73, 0x20, 0x44, 0x75, - 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x33, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, - 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, - 0x65, 0x73, 0x20, 0x53, 0x74, 0x72, 0x61, 0x74, 0x75, 0x73, 0x20, 0x58, - 0x4c, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x64, 0x31, 0x62, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x38, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, - 0x30, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x72, 0x65, - 0x65, 0x74, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x65, 0x72, 0x20, 0x49, - 0x56, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x20, 0x54, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x62, 0x30, 0x37, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x61, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x75, 0x6e, - 0x63, 0x6f, 0x6d, 0x20, 0x53, 0x46, 0x58, 0x20, 0x50, 0x6c, 0x75, 0x73, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x36, 0x36, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, - 0x38, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x53, 0x75, 0x70, 0x65, 0x72, 0x20, 0x4a, 0x6f, 0x79, - 0x20, 0x42, 0x6f, 0x78, 0x20, 0x35, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x75, 0x70, 0x65, - 0x72, 0x20, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x50, 0x6f, 0x72, 0x74, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x35, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x66, 0x30, 0x65, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x5a, 0x4d, 0x59, 0x20, - 0x50, 0x6f, 0x77, 0x65, 0x72, 0x20, 0x33, 0x20, 0x54, 0x75, 0x72, 0x62, - 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x35, 0x37, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x53, 0x5a, 0x4d, 0x59, 0x20, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x20, - 0x44, 0x53, 0x34, 0x20, 0x57, 0x69, 0x72, 0x65, 0x64, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x35, 0x37, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x32, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x5a, 0x4d, 0x59, 0x20, 0x50, - 0x6f, 0x77, 0x65, 0x72, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, - 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x33, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x53, 0x5a, 0x4d, 0x59, 0x20, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x20, 0x50, - 0x53, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x62, 0x61, 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x54, 0x65, 0x63, 0x68, 0x6e, 0x6f, 0x6c, 0x6f, 0x67, 0x79, - 0x20, 0x49, 0x6e, 0x6e, 0x6f, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, - 0x50, 0x53, 0x32, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x37, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x63, 0x31, 0x38, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x54, 0x47, 0x5a, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x35, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, - 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x44, 0x75, 0x61, 0x6c, - 0x20, 0x41, 0x6e, 0x61, 0x6c, 0x6f, 0x67, 0x20, 0x33, 0x2e, 0x32, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x62, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, - 0x72, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x41, 0x6e, 0x61, 0x6c, 0x6f, - 0x67, 0x20, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x30, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, - 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x54, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x32, 0x33, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, - 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x44, 0x75, 0x61, - 0x6c, 0x20, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x20, 0x50, 0x6c, - 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x64, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, - 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x65, - 0x53, 0x77, 0x61, 0x70, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x35, 0x30, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x39, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, - 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x46, 0x69, 0x72, 0x65, - 0x73, 0x74, 0x6f, 0x72, 0x6d, 0x20, 0x44, 0x69, 0x67, 0x69, 0x74, 0x61, - 0x6c, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x62, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, - 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x46, - 0x69, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x6d, 0x20, 0x44, 0x75, 0x61, - 0x6c, 0x20, 0x41, 0x6e, 0x61, 0x6c, 0x6f, 0x67, 0x20, 0x32, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, - 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x46, 0x69, 0x72, 0x65, - 0x73, 0x74, 0x6f, 0x72, 0x6d, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x50, - 0x6f, 0x77, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, - 0x73, 0x74, 0x65, 0x72, 0x20, 0x46, 0x69, 0x72, 0x65, 0x73, 0x74, 0x6f, - 0x72, 0x6d, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x50, 0x6f, 0x77, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, - 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, - 0x74, 0x65, 0x72, 0x20, 0x47, 0x50, 0x20, 0x58, 0x49, 0x44, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x36, 0x32, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x32, 0x35, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, - 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x47, 0x50, 0x58, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x64, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, - 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x52, - 0x75, 0x6e, 0x20, 0x4e, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x20, 0x50, - 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x64, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, - 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, - 0x52, 0x75, 0x6e, 0x20, 0x4e, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x20, - 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x64, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, - 0x72, 0x75, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x54, - 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x32, 0x62, 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x6d, - 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x56, 0x69, 0x62, 0x72, 0x61, 0x74, - 0x69, 0x6e, 0x67, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x37, 0x31, 0x64, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x54, 0x6f, 0x6d, 0x65, 0x65, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, - 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x62, 0x64, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, - 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x54, 0x6f, 0x6d, 0x65, 0x65, 0x20, 0x53, 0x4e, 0x45, - 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x38, 0x31, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x37, 0x63, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x6f, 0x6f, 0x64, - 0x6c, 0x65, 0x73, 0x20, 0x32, 0x30, 0x30, 0x38, 0x20, 0x43, 0x68, 0x69, - 0x6d, 0x70, 0x20, 0x50, 0x43, 0x20, 0x50, 0x53, 0x33, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x30, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, - 0x6f, 0x72, 0x69, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x63, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x39, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x54, 0x6f, 0x72, 0x69, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x30, 0x61, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x52, 0x42, - 0x6f, 0x74, 0x20, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x20, 0x4a, - 0x6f, 0x79, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x52, 0x42, 0x6f, 0x74, - 0x20, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x20, 0x4a, 0x6f, 0x79, - 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x36, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x64, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x52, 0x42, 0x6f, 0x74, 0x20, 0x56, - 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x20, 0x4a, 0x6f, 0x79, 0x70, 0x61, - 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x32, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, - 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x66, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x54, 0x52, 0x42, 0x6f, 0x74, 0x20, 0x56, 0x69, 0x72, - 0x74, 0x75, 0x61, 0x6c, 0x20, 0x4a, 0x6f, 0x79, 0x70, 0x61, 0x64, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x66, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x63, 0x35, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x54, 0x72, 0x75, 0x73, 0x74, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, - 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x54, 0x77, 0x69, 0x6e, 0x20, 0x50, 0x53, 0x32, 0x20, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x35, 0x31, 0x39, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x36, 0x37, 0x38, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x6e, 0x69, 0x70, - 0x6c, 0x61, 0x79, 0x20, 0x55, 0x36, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, 0x53, - 0x42, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x55, - 0x53, 0x42, 0x20, 0x67, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, - 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x55, 0x53, 0x42, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, - 0x61, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x61, - 0x31, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x61, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x56, 0x69, 0x63, 0x74, - 0x72, 0x69, 0x78, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x46, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x56, 0x69, 0x63, 0x74, 0x72, 0x69, 0x78, 0x20, 0x50, - 0x72, 0x6f, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x20, 0x50, 0x53, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, - 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x33, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x56, 0x52, 0x20, 0x42, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x34, 0x66, 0x34, 0x64, - 0x34, 0x64, 0x34, 0x31, 0x34, 0x65, 0x34, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x56, 0x58, 0x20, 0x47, 0x61, - 0x6d, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, - 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x38, 0x36, 0x32, - 0x36, 0x66, 0x37, 0x38, 0x32, 0x30, 0x33, 0x33, 0x33, 0x36, 0x33, 0x30, - 0x32, 0x30, 0x35, 0x37, 0x36, 0x39, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, - 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x39, 0x30, 0x37, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, - 0x65, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x39, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, - 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x61, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x61, 0x31, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x37, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, - 0x65, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, - 0x20, 0x45, 0x61, 0x73, 0x79, 0x53, 0x4d, 0x58, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x61, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, - 0x36, 0x30, 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x32, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x66, 0x30, 0x65, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, - 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, - 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x38, 0x36, 0x32, 0x36, 0x66, 0x37, 0x38, 0x32, 0x30, 0x34, 0x37, 0x36, - 0x31, 0x36, 0x64, 0x36, 0x35, 0x37, 0x30, 0x36, 0x31, 0x30, 0x30, 0x2c, - 0x58, 0x62, 0x6f, 0x78, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x30, 0x62, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x64, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, - 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x61, 0x30, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x65, 0x61, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, - 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, - 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x66, 0x64, 0x30, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x30, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x65, 0x33, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, - 0x65, 0x20, 0x45, 0x6c, 0x69, 0x74, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x32, 0x30, 0x62, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x45, 0x6c, 0x69, - 0x74, 0x65, 0x20, 0x32, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, - 0x65, 0x20, 0x45, 0x6c, 0x69, 0x74, 0x65, 0x20, 0x53, 0x65, 0x72, 0x69, - 0x65, 0x73, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x65, 0x61, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x62, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, - 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x36, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, - 0x61, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, - 0x20, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x62, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x31, 0x32, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, - 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, - 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, - 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, - 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, - 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x39, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, - 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x32, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, - 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, - 0x31, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, - 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x62, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, - 0x35, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, - 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, - 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, - 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, - 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, - 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, - 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, - 0x62, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, - 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, - 0x31, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, - 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x35, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, - 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x37, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, - 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x36, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x32, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, - 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, - 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x62, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x58, 0x62, 0x6f, 0x78, 0x20, 0x57, 0x69, 0x72, 0x65, 0x6c, 0x65, 0x73, - 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, - 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x35, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x34, - 0x33, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x58, 0x45, 0x4f, 0x58, 0x20, 0x53, 0x4c, 0x36, 0x35, 0x35, - 0x36, 0x20, 0x42, 0x4b, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, 0x32, 0x37, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x34, 0x33, 0x31, 0x30, 0x30, 0x30, 0x30, 0x32, 0x39, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x69, 0x61, 0x6f, 0x4d, 0x69, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x32, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x34, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, 0x69, 0x6e, 0x75, - 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x65, 0x31, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x58, 0x69, 0x6e, 0x4d, 0x6f, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, - 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x34, 0x2c, - 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, - 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x78, 0x69, 0x6e, 0x70, - 0x75, 0x74, 0x2c, 0x58, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x30, 0x30, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, - 0x31, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x5a, 0x65, 0x72, 0x6f, 0x70, 0x6c, - 0x75, 0x73, 0x20, 0x50, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x30, 0x33, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x30, 0x31, 0x65, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x5a, 0x65, 0x72, 0x6f, 0x70, 0x6c, 0x75, - 0x73, 0x20, 0x50, 0x34, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x4c, - 0x69, 0x6e, 0x75, 0x78, 0x2c, 0x0d, 0x0a, 0x0d, 0x0a, 0x23, 0x20, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x0d, 0x0a, 0x33, 0x38, 0x36, 0x35, - 0x33, 0x39, 0x36, 0x34, 0x36, 0x33, 0x33, 0x32, 0x33, 0x30, 0x36, 0x36, - 0x36, 0x34, 0x36, 0x33, 0x33, 0x34, 0x33, 0x33, 0x33, 0x34, 0x33, 0x31, - 0x33, 0x35, 0x33, 0x33, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, - 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x36, 0x36, 0x36, 0x36, 0x32, 0x36, 0x34, - 0x33, 0x31, 0x36, 0x36, 0x33, 0x30, 0x36, 0x35, 0x33, 0x39, 0x36, 0x35, - 0x36, 0x33, 0x36, 0x36, 0x33, 0x34, 0x33, 0x38, 0x36, 0x32, 0x33, 0x34, - 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, - 0x74, 0x65, 0x72, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x33, 0x38, 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, - 0x32, 0x30, 0x34, 0x31, 0x37, 0x32, 0x36, 0x33, 0x36, 0x31, 0x36, 0x34, - 0x36, 0x35, 0x32, 0x30, 0x35, 0x33, 0x37, 0x34, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, - 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x31, 0x33, 0x39, 0x33, - 0x39, 0x36, 0x32, 0x36, 0x34, 0x36, 0x34, 0x33, 0x34, 0x33, 0x39, 0x33, - 0x38, 0x33, 0x36, 0x33, 0x35, 0x36, 0x36, 0x33, 0x31, 0x36, 0x33, 0x36, - 0x31, 0x33, 0x32, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x41, - 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, - 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x34, 0x33, 0x32, 0x33, 0x31, 0x33, 0x39, - 0x33, 0x34, 0x36, 0x31, 0x33, 0x31, 0x33, 0x30, 0x36, 0x32, 0x33, 0x33, - 0x36, 0x33, 0x36, 0x35, 0x36, 0x32, 0x36, 0x36, 0x33, 0x37, 0x33, 0x38, - 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x41, 0x72, 0x63, 0x61, - 0x64, 0x65, 0x20, 0x53, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, - 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x36, 0x34, 0x36, 0x34, 0x33, 0x35, 0x36, 0x35, 0x33, 0x38, 0x36, 0x31, - 0x33, 0x36, 0x36, 0x31, 0x33, 0x32, 0x36, 0x35, 0x36, 0x36, 0x33, 0x32, - 0x33, 0x36, 0x36, 0x33, 0x36, 0x35, 0x36, 0x34, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, 0x20, 0x53, - 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, - 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x33, 0x33, - 0x31, 0x33, 0x34, 0x33, 0x33, 0x33, 0x35, 0x33, 0x35, 0x33, 0x39, 0x33, - 0x30, 0x36, 0x36, 0x33, 0x34, 0x36, 0x35, 0x36, 0x34, 0x33, 0x36, 0x33, - 0x35, 0x33, 0x34, 0x33, 0x32, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x44, 0x6f, 0x67, 0x62, 0x6f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x34, 0x32, 0x36, - 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, 0x34, 0x34, 0x36, - 0x66, 0x36, 0x37, 0x36, 0x32, 0x36, 0x66, 0x36, 0x65, 0x36, 0x35, 0x32, - 0x30, 0x34, 0x64, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x44, - 0x6f, 0x67, 0x62, 0x6f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x34, 0x33, 0x34, 0x33, - 0x34, 0x33, 0x39, 0x33, 0x37, 0x33, 0x32, 0x33, 0x36, 0x36, 0x32, 0x33, - 0x34, 0x36, 0x36, 0x33, 0x34, 0x33, 0x39, 0x33, 0x34, 0x33, 0x37, 0x36, - 0x32, 0x33, 0x33, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x46, - 0x43, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x34, 0x32, 0x36, - 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, 0x33, 0x38, 0x34, - 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, 0x34, - 0x63, 0x36, 0x39, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4c, - 0x69, 0x74, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x30, 0x36, - 0x34, 0x33, 0x33, 0x33, 0x32, 0x33, 0x37, 0x33, 0x36, 0x36, 0x33, 0x33, - 0x31, 0x33, 0x32, 0x36, 0x33, 0x33, 0x31, 0x36, 0x36, 0x33, 0x37, 0x33, - 0x35, 0x36, 0x36, 0x33, 0x31, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x33, 0x38, 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, - 0x66, 0x32, 0x30, 0x34, 0x63, 0x36, 0x39, 0x37, 0x34, 0x36, 0x35, 0x32, - 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, - 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x32, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x32, 0x36, 0x35, 0x36, 0x33, 0x33, - 0x31, 0x36, 0x32, 0x36, 0x34, 0x36, 0x31, 0x33, 0x36, 0x33, 0x36, 0x33, - 0x34, 0x36, 0x33, 0x33, 0x37, 0x33, 0x35, 0x33, 0x35, 0x33, 0x30, 0x33, - 0x32, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, - 0x65, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x33, - 0x39, 0x33, 0x39, 0x33, 0x36, 0x36, 0x31, 0x36, 0x34, 0x33, 0x36, 0x33, - 0x38, 0x33, 0x30, 0x36, 0x32, 0x36, 0x36, 0x36, 0x32, 0x33, 0x32, 0x36, - 0x35, 0x33, 0x33, 0x33, 0x38, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x53, 0x45, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x34, 0x32, 0x36, 0x39, 0x37, - 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, 0x34, 0x63, 0x36, 0x39, 0x37, - 0x34, 0x36, 0x35, 0x32, 0x30, 0x35, 0x33, 0x34, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4c, 0x69, 0x74, - 0x65, 0x20, 0x53, 0x45, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x39, - 0x33, 0x35, 0x36, 0x34, 0x33, 0x30, 0x36, 0x31, 0x36, 0x35, 0x36, 0x32, - 0x33, 0x36, 0x36, 0x34, 0x36, 0x36, 0x36, 0x34, 0x36, 0x36, 0x33, 0x36, - 0x36, 0x34, 0x33, 0x34, 0x33, 0x35, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x53, 0x45, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, - 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, - 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, - 0x61, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x31, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, - 0x33, 0x66, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, - 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x32, - 0x33, 0x32, 0x33, 0x31, 0x36, 0x31, 0x33, 0x36, 0x33, 0x30, 0x33, 0x37, - 0x36, 0x32, 0x33, 0x36, 0x33, 0x37, 0x33, 0x32, 0x36, 0x34, 0x33, 0x38, - 0x36, 0x34, 0x33, 0x36, 0x33, 0x34, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, - 0x0d, 0x0a, 0x33, 0x33, 0x36, 0x35, 0x36, 0x32, 0x36, 0x36, 0x33, 0x35, - 0x33, 0x36, 0x33, 0x30, 0x36, 0x34, 0x33, 0x39, 0x36, 0x36, 0x36, 0x35, - 0x33, 0x32, 0x33, 0x38, 0x36, 0x34, 0x36, 0x32, 0x36, 0x34, 0x2c, 0x38, - 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, - 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, - 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, - 0x34, 0x64, 0x33, 0x33, 0x33, 0x30, 0x32, 0x30, 0x34, 0x64, 0x36, 0x66, - 0x36, 0x34, 0x36, 0x62, 0x36, 0x39, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, - 0x0d, 0x0a, 0x33, 0x39, 0x33, 0x36, 0x36, 0x36, 0x33, 0x30, 0x36, 0x36, - 0x33, 0x30, 0x36, 0x32, 0x33, 0x37, 0x33, 0x32, 0x33, 0x37, 0x36, 0x31, - 0x36, 0x35, 0x36, 0x36, 0x33, 0x35, 0x33, 0x34, 0x33, 0x37, 0x2c, 0x38, - 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x34, - 0x36, 0x35, 0x33, 0x35, 0x33, 0x33, 0x33, 0x31, 0x33, 0x35, 0x33, 0x37, - 0x33, 0x37, 0x33, 0x39, 0x33, 0x34, 0x33, 0x32, 0x33, 0x34, 0x33, 0x36, - 0x33, 0x34, 0x33, 0x35, 0x36, 0x33, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x36, 0x33, 0x35, 0x36, 0x34, 0x33, 0x38, - 0x33, 0x34, 0x36, 0x31, 0x33, 0x36, 0x33, 0x36, 0x36, 0x33, 0x33, 0x37, - 0x33, 0x38, 0x36, 0x34, 0x33, 0x37, 0x36, 0x35, 0x33, 0x39, 0x33, 0x34, - 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, - 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x36, 0x36, 0x33, 0x39, 0x33, 0x30, 0x36, 0x34, 0x33, 0x39, 0x33, - 0x31, 0x36, 0x32, 0x33, 0x30, 0x33, 0x37, 0x33, 0x32, 0x33, 0x35, 0x36, - 0x36, 0x36, 0x35, 0x36, 0x36, 0x36, 0x33, 0x36, 0x36, 0x2c, 0x38, 0x42, - 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4d, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x33, 0x36, 0x36, 0x33, - 0x34, 0x33, 0x31, 0x33, 0x32, 0x36, 0x31, 0x33, 0x34, 0x33, 0x33, 0x33, - 0x33, 0x36, 0x36, 0x33, 0x39, 0x33, 0x32, 0x33, 0x33, 0x36, 0x31, 0x36, - 0x36, 0x33, 0x33, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, - 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, - 0x34, 0x36, 0x66, 0x32, 0x30, 0x34, 0x65, 0x33, 0x33, 0x33, 0x30, 0x32, - 0x30, 0x34, 0x64, 0x36, 0x66, 0x36, 0x34, 0x36, 0x62, 0x36, 0x39, 0x2c, - 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x36, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x35, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, - 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, - 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, - 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, - 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x36, 0x35, 0x32, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x38, - 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, - 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, - 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, 0x53, 0x33, 0x30, - 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, - 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x32, 0x30, 0x33, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x4e, 0x45, - 0x53, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x33, - 0x31, 0x33, 0x34, 0x33, 0x33, 0x36, 0x34, 0x33, 0x31, 0x33, 0x31, 0x36, - 0x35, 0x36, 0x32, 0x36, 0x32, 0x33, 0x30, 0x36, 0x36, 0x33, 0x31, 0x33, - 0x37, 0x33, 0x31, 0x36, 0x36, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x50, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, - 0x33, 0x32, 0x36, 0x35, 0x33, 0x36, 0x36, 0x34, 0x33, 0x33, 0x33, 0x39, - 0x33, 0x35, 0x33, 0x38, 0x36, 0x35, 0x33, 0x32, 0x33, 0x30, 0x36, 0x33, - 0x36, 0x31, 0x36, 0x33, 0x33, 0x39, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x50, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, - 0x38, 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, - 0x30, 0x35, 0x30, 0x33, 0x33, 0x33, 0x30, 0x32, 0x30, 0x36, 0x33, 0x36, - 0x63, 0x36, 0x31, 0x37, 0x33, 0x37, 0x33, 0x2c, 0x38, 0x42, 0x69, 0x74, - 0x44, 0x6f, 0x20, 0x50, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x33, 0x35, 0x33, 0x37, 0x36, 0x36, 0x36, 0x34, 0x33, 0x34, 0x33, 0x31, - 0x36, 0x34, 0x33, 0x38, 0x36, 0x33, 0x33, 0x33, 0x36, 0x31, 0x36, 0x35, - 0x33, 0x35, 0x33, 0x33, 0x33, 0x34, 0x33, 0x34, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, - 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x34, - 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, 0x33, - 0x38, 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, - 0x30, 0x35, 0x30, 0x37, 0x32, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x33, 0x38, 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, - 0x32, 0x30, 0x35, 0x30, 0x37, 0x32, 0x36, 0x66, 0x32, 0x30, 0x33, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x36, 0x32, 0x33, 0x37, 0x33, 0x37, 0x33, 0x39, 0x33, - 0x36, 0x36, 0x35, 0x33, 0x37, 0x33, 0x36, 0x33, 0x31, 0x36, 0x36, 0x33, - 0x32, 0x36, 0x32, 0x33, 0x38, 0x36, 0x35, 0x33, 0x34, 0x36, 0x33, 0x2c, - 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x32, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x33, 0x38, 0x33, 0x38, 0x36, 0x34, 0x36, 0x34, 0x36, 0x31, 0x33, - 0x30, 0x33, 0x34, 0x33, 0x32, 0x36, 0x34, 0x33, 0x35, 0x36, 0x32, 0x36, - 0x31, 0x33, 0x30, 0x33, 0x39, 0x36, 0x35, 0x36, 0x35, 0x2c, 0x38, 0x42, - 0x69, 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x34, 0x32, - 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, 0x33, 0x38, - 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, - 0x35, 0x32, 0x36, 0x35, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, - 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, - 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x36, 0x36, 0x33, 0x30, 0x33, 0x32, 0x33, 0x30, 0x33, - 0x34, 0x33, 0x30, 0x33, 0x38, 0x36, 0x31, 0x33, 0x33, 0x36, 0x35, 0x36, - 0x32, 0x33, 0x39, 0x36, 0x34, 0x33, 0x39, 0x33, 0x37, 0x36, 0x36, 0x2c, - 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x52, 0x65, 0x63, 0x65, 0x69, - 0x76, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, - 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, - 0x35, 0x33, 0x33, 0x33, 0x33, 0x30, 0x32, 0x30, 0x34, 0x64, 0x36, 0x66, - 0x36, 0x34, 0x36, 0x62, 0x36, 0x39, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x36, 0x36, 0x33, 0x31, 0x36, 0x34, 0x36, 0x32, 0x33, 0x35, 0x33, 0x35, - 0x36, 0x31, 0x33, 0x37, 0x36, 0x33, 0x33, 0x30, 0x33, 0x34, 0x36, 0x34, - 0x36, 0x32, 0x33, 0x31, 0x36, 0x31, 0x33, 0x37, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x53, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, - 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, - 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x38, - 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, 0x33, 0x30, 0x20, 0x50, - 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, - 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, - 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x36, 0x31, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, - 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x34, 0x32, - 0x36, 0x39, 0x37, 0x34, 0x36, 0x34, 0x36, 0x66, 0x32, 0x30, 0x35, 0x33, - 0x34, 0x36, 0x33, 0x33, 0x33, 0x30, 0x32, 0x30, 0x35, 0x30, 0x37, 0x32, - 0x36, 0x66, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, - 0x53, 0x46, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, - 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x31, 0x36, 0x32, 0x33, 0x33, - 0x33, 0x34, 0x36, 0x33, 0x36, 0x33, 0x33, 0x38, 0x36, 0x34, 0x33, 0x32, - 0x33, 0x33, 0x33, 0x38, 0x33, 0x37, 0x33, 0x35, 0x33, 0x32, 0x36, 0x34, - 0x33, 0x39, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x46, - 0x43, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x33, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x35, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, - 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, - 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, - 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, - 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x32, 0x38, - 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, - 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, - 0x0d, 0x0a, 0x33, 0x38, 0x33, 0x31, 0x36, 0x32, 0x33, 0x30, 0x36, 0x31, - 0x33, 0x39, 0x33, 0x31, 0x36, 0x31, 0x33, 0x39, 0x36, 0x34, 0x33, 0x35, - 0x36, 0x36, 0x36, 0x36, 0x33, 0x35, 0x33, 0x38, 0x33, 0x39, 0x2c, 0x38, - 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x34, 0x32, 0x36, - 0x39, 0x37, 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, 0x35, 0x33, 0x34, - 0x65, 0x33, 0x33, 0x33, 0x30, 0x32, 0x30, 0x34, 0x64, 0x36, 0x66, 0x36, - 0x34, 0x36, 0x62, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, - 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, - 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x36, 0x35, 0x33, 0x32, 0x33, 0x35, 0x36, 0x33, 0x33, 0x30, 0x33, 0x32, - 0x33, 0x31, 0x36, 0x34, 0x36, 0x35, 0x33, 0x31, 0x33, 0x38, 0x33, 0x31, - 0x36, 0x32, 0x36, 0x34, 0x36, 0x33, 0x33, 0x35, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x35, 0x33, 0x38, 0x33, 0x35, 0x33, - 0x31, 0x33, 0x34, 0x36, 0x32, 0x36, 0x33, 0x36, 0x35, 0x33, 0x33, 0x33, - 0x30, 0x33, 0x30, 0x36, 0x32, 0x33, 0x38, 0x33, 0x35, 0x33, 0x31, 0x33, - 0x31, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, - 0x30, 0x20, 0x50, 0x50, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, - 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, - 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, - 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, - 0x64, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x36, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x66, 0x66, 0x66, 0x66, 0x30, 0x66, 0x30, 0x30, 0x2c, 0x38, 0x42, - 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, - 0x6f, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x36, 0x36, 0x35, - 0x33, 0x36, 0x33, 0x38, 0x36, 0x35, 0x36, 0x36, 0x33, 0x32, 0x33, 0x32, - 0x36, 0x32, 0x33, 0x35, 0x33, 0x34, 0x36, 0x32, 0x36, 0x34, 0x36, 0x36, - 0x33, 0x36, 0x36, 0x31, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, - 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, 0x6c, 0x75, - 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, - 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x33, 0x38, 0x33, 0x30, 0x33, 0x32, 0x33, 0x32, 0x33, 0x39, 0x33, 0x31, - 0x33, 0x33, 0x33, 0x38, 0x33, 0x38, 0x33, 0x36, 0x33, 0x36, 0x36, 0x33, - 0x33, 0x30, 0x33, 0x34, 0x36, 0x34, 0x36, 0x32, 0x2c, 0x38, 0x42, 0x69, - 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x72, 0x6f, - 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, - 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x33, 0x34, 0x36, 0x36, 0x33, 0x30, 0x33, - 0x34, 0x36, 0x31, 0x33, 0x35, 0x33, 0x36, 0x33, 0x33, 0x33, 0x35, 0x33, - 0x36, 0x36, 0x32, 0x36, 0x35, 0x36, 0x35, 0x36, 0x36, 0x36, 0x36, 0x2c, - 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, - 0x50, 0x72, 0x6f, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x34, 0x32, 0x36, 0x39, 0x37, - 0x34, 0x34, 0x34, 0x36, 0x66, 0x32, 0x30, 0x35, 0x33, 0x34, 0x65, 0x33, - 0x33, 0x33, 0x30, 0x32, 0x30, 0x35, 0x30, 0x37, 0x32, 0x36, 0x66, 0x32, - 0x62, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, - 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x31, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, - 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, - 0x39, 0x32, 0x30, 0x34, 0x33, 0x36, 0x66, 0x36, 0x64, 0x37, 0x30, 0x37, - 0x35, 0x37, 0x34, 0x36, 0x35, 0x37, 0x32, 0x32, 0x30, 0x34, 0x35, 0x36, - 0x65, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, - 0x30, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, - 0x0d, 0x0a, 0x36, 0x36, 0x33, 0x30, 0x36, 0x33, 0x33, 0x31, 0x36, 0x34, - 0x33, 0x35, 0x33, 0x31, 0x33, 0x33, 0x33, 0x32, 0x33, 0x30, 0x33, 0x30, - 0x36, 0x34, 0x33, 0x37, 0x33, 0x35, 0x33, 0x39, 0x33, 0x36, 0x2c, 0x38, - 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, - 0x72, 0x6f, 0x20, 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x32, 0x30, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, - 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x45, 0x53, - 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x35, 0x31, 0x32, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x61, 0x62, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x30, 0x66, 0x30, 0x30, - 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, 0x20, 0x53, 0x4e, 0x45, 0x53, - 0x33, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x33, 0x30, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x33, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x79, 0x3a, - 0x62, 0x32, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, - 0x33, 0x36, 0x36, 0x36, 0x36, 0x36, 0x33, 0x33, 0x31, 0x36, 0x31, 0x36, - 0x34, 0x36, 0x35, 0x33, 0x39, 0x33, 0x37, 0x33, 0x32, 0x36, 0x32, 0x33, - 0x37, 0x36, 0x31, 0x33, 0x33, 0x33, 0x31, 0x2c, 0x38, 0x42, 0x69, 0x74, - 0x44, 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, - 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, - 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x36, 0x34, 0x36, 0x66, 0x32, 0x30, - 0x35, 0x61, 0x36, 0x35, 0x37, 0x32, 0x36, 0x66, 0x32, 0x30, 0x34, 0x37, - 0x36, 0x31, 0x36, 0x64, 0x36, 0x35, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, - 0x30, 0x31, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, - 0x66, 0x30, 0x66, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x38, 0x32, 0x64, 0x30, 0x30, 0x30, - 0x30, 0x33, 0x30, 0x33, 0x32, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, - 0x66, 0x30, 0x66, 0x30, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x33, 0x36, - 0x36, 0x33, 0x34, 0x33, 0x34, 0x33, 0x39, 0x33, 0x33, 0x36, 0x32, 0x33, - 0x30, 0x33, 0x30, 0x33, 0x33, 0x36, 0x31, 0x36, 0x36, 0x33, 0x30, 0x33, - 0x34, 0x36, 0x33, 0x33, 0x37, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, - 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x34, - 0x36, 0x35, 0x36, 0x33, 0x33, 0x30, 0x36, 0x32, 0x36, 0x33, 0x36, 0x31, - 0x36, 0x36, 0x36, 0x34, 0x33, 0x38, 0x33, 0x32, 0x33, 0x32, 0x36, 0x36, - 0x36, 0x33, 0x33, 0x39, 0x36, 0x33, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, - 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x33, - 0x33, 0x39, 0x36, 0x36, 0x36, 0x36, 0x33, 0x38, 0x36, 0x35, 0x36, 0x34, - 0x33, 0x39, 0x33, 0x33, 0x33, 0x34, 0x33, 0x39, 0x33, 0x32, 0x33, 0x36, - 0x33, 0x38, 0x36, 0x36, 0x33, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, - 0x6f, 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x33, 0x36, - 0x33, 0x33, 0x34, 0x33, 0x35, 0x36, 0x32, 0x33, 0x32, 0x36, 0x33, 0x33, - 0x37, 0x33, 0x34, 0x36, 0x36, 0x33, 0x34, 0x33, 0x34, 0x36, 0x31, 0x36, - 0x34, 0x36, 0x34, 0x33, 0x30, 0x2c, 0x38, 0x42, 0x69, 0x74, 0x44, 0x6f, - 0x20, 0x5a, 0x65, 0x72, 0x6f, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x32, 0x33, 0x33, - 0x33, 0x36, 0x33, 0x34, 0x36, 0x31, 0x33, 0x37, 0x33, 0x35, 0x36, 0x31, - 0x36, 0x31, 0x36, 0x33, 0x33, 0x32, 0x36, 0x31, 0x36, 0x35, 0x33, 0x32, - 0x33, 0x37, 0x33, 0x31, 0x2c, 0x41, 0x6d, 0x61, 0x7a, 0x6f, 0x6e, 0x20, - 0x4c, 0x75, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x34, 0x31, 0x37, 0x33, 0x37, 0x34, 0x37, 0x32, 0x36, 0x66, 0x32, 0x30, - 0x36, 0x33, 0x36, 0x39, 0x37, 0x34, 0x37, 0x39, 0x32, 0x30, 0x36, 0x64, - 0x36, 0x39, 0x36, 0x65, 0x36, 0x39, 0x32, 0x30, 0x2c, 0x41, 0x73, 0x74, - 0x72, 0x6f, 0x20, 0x43, 0x69, 0x74, 0x79, 0x20, 0x4d, 0x69, 0x6e, 0x69, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, - 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x32, - 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x35, 0x36, - 0x34, 0x33, 0x32, 0x36, 0x33, 0x33, 0x31, 0x33, 0x32, 0x36, 0x34, 0x33, - 0x38, 0x36, 0x31, 0x33, 0x34, 0x33, 0x37, 0x36, 0x33, 0x36, 0x32, 0x33, - 0x36, 0x33, 0x34, 0x33, 0x35, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, 0x20, - 0x56, 0x43, 0x53, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x32, 0x33, 0x35, 0x33, 0x38, 0x33, - 0x31, 0x36, 0x34, 0x33, 0x35, 0x36, 0x36, 0x33, 0x30, 0x36, 0x35, 0x36, - 0x33, 0x36, 0x34, 0x33, 0x30, 0x36, 0x35, 0x33, 0x35, 0x36, 0x32, 0x33, - 0x39, 0x2c, 0x41, 0x74, 0x61, 0x72, 0x69, 0x20, 0x56, 0x43, 0x53, 0x20, - 0x4d, 0x6f, 0x64, 0x65, 0x72, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x32, 0x33, 0x30, - 0x33, 0x31, 0x36, 0x35, 0x36, 0x32, 0x36, 0x31, 0x33, 0x38, 0x33, 0x34, - 0x33, 0x39, 0x36, 0x32, 0x33, 0x36, 0x33, 0x36, 0x36, 0x36, 0x33, 0x34, - 0x36, 0x31, 0x36, 0x35, 0x2c, 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x20, 0x4d, - 0x61, 0x72, 0x73, 0x20, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x33, 0x38, 0x33, 0x33, 0x33, - 0x37, 0x33, 0x34, 0x33, 0x35, 0x36, 0x34, 0x33, 0x36, 0x36, 0x31, 0x33, - 0x31, 0x33, 0x32, 0x33, 0x30, 0x36, 0x34, 0x36, 0x31, 0x33, 0x35, 0x36, - 0x31, 0x2c, 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x20, 0x4d, 0x61, 0x72, 0x73, - 0x20, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x33, 0x34, 0x33, 0x31, 0x33, 0x34, 0x33, 0x30, 0x33, - 0x34, 0x33, 0x31, 0x36, 0x31, 0x36, 0x35, 0x33, 0x36, 0x36, 0x35, 0x33, - 0x35, 0x33, 0x37, 0x33, 0x37, 0x33, 0x32, 0x33, 0x33, 0x36, 0x35, 0x2c, - 0x45, 0x6c, 0x65, 0x63, 0x6f, 0x6d, 0x20, 0x4a, 0x43, 0x2d, 0x57, 0x30, - 0x31, 0x55, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x31, - 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, - 0x0d, 0x0a, 0x34, 0x38, 0x37, 0x35, 0x36, 0x39, 0x34, 0x61, 0x36, 0x39, - 0x36, 0x31, 0x32, 0x30, 0x34, 0x61, 0x34, 0x33, 0x32, 0x64, 0x35, 0x37, - 0x33, 0x30, 0x33, 0x31, 0x35, 0x35, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x45, - 0x6c, 0x65, 0x63, 0x6f, 0x6d, 0x20, 0x4a, 0x43, 0x2d, 0x57, 0x30, 0x31, - 0x55, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x31, 0x2c, - 0x79, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x33, 0x30, 0x33, 0x36, 0x33, 0x32, 0x33, 0x30, 0x36, 0x35, 0x33, - 0x36, 0x33, 0x35, 0x36, 0x33, 0x33, 0x38, 0x36, 0x33, 0x33, 0x36, 0x36, - 0x33, 0x33, 0x38, 0x36, 0x32, 0x33, 0x32, 0x36, 0x35, 0x2c, 0x45, 0x76, - 0x6f, 0x20, 0x56, 0x52, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x34, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x32, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x64, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x46, 0x6c, - 0x79, 0x64, 0x69, 0x67, 0x69, 0x20, 0x56, 0x61, 0x64, 0x65, 0x72, 0x20, - 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, - 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, - 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x62, - 0x63, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, - 0x47, 0x61, 0x6d, 0x65, 0x53, 0x69, 0x72, 0x20, 0x47, 0x33, 0x77, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x33, 0x34, 0x33, 0x32, 0x33, 0x36, 0x36, 0x32, 0x36, 0x35, 0x33, - 0x33, 0x33, 0x33, 0x36, 0x33, 0x36, 0x33, 0x33, 0x30, 0x33, 0x30, 0x36, - 0x36, 0x33, 0x31, 0x33, 0x32, 0x36, 0x32, 0x33, 0x33, 0x2c, 0x47, 0x6f, - 0x6f, 0x67, 0x6c, 0x65, 0x20, 0x4e, 0x65, 0x78, 0x75, 0x73, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x35, 0x33, 0x38, 0x33, 0x36, 0x33, 0x33, - 0x33, 0x35, 0x33, 0x39, 0x33, 0x35, 0x33, 0x39, 0x36, 0x35, 0x33, 0x34, - 0x33, 0x39, 0x33, 0x32, 0x33, 0x30, 0x36, 0x31, 0x36, 0x35, 0x36, 0x34, - 0x2c, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x20, 0x53, 0x74, 0x61, 0x64, - 0x69, 0x61, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x64, 0x36, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x65, 0x35, 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x64, 0x66, 0x66, 0x66, - 0x33, 0x66, 0x30, 0x30, 0x2c, 0x47, 0x50, 0x44, 0x20, 0x58, 0x44, 0x20, - 0x50, 0x6c, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, - 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x64, 0x36, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x65, 0x35, - 0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x64, 0x66, 0x66, 0x66, 0x33, 0x66, - 0x38, 0x30, 0x2c, 0x47, 0x50, 0x44, 0x20, 0x58, 0x44, 0x20, 0x50, 0x6c, - 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x36, 0x36, 0x33, 0x33, 0x30, 0x33, 0x30, - 0x36, 0x35, 0x36, 0x31, 0x33, 0x31, 0x36, 0x36, 0x33, 0x38, 0x33, 0x37, - 0x33, 0x39, 0x36, 0x35, 0x36, 0x32, 0x33, 0x32, 0x33, 0x39, 0x33, 0x35, - 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x42, 0x61, 0x74, 0x74, 0x6c, 0x65, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x35, 0x36, 0x32, 0x33, - 0x34, 0x36, 0x36, 0x33, 0x34, 0x33, 0x34, 0x33, 0x33, 0x36, 0x35, 0x33, - 0x37, 0x33, 0x39, 0x33, 0x34, 0x36, 0x34, 0x33, 0x34, 0x36, 0x33, 0x36, - 0x33, 0x33, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, - 0x68, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, - 0x64, 0x65, 0x72, 0x20, 0x33, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x34, 0x38, 0x34, 0x66, 0x35, 0x32, 0x34, 0x39, - 0x32, 0x30, 0x34, 0x33, 0x34, 0x66, 0x32, 0x65, 0x32, 0x63, 0x34, 0x63, - 0x35, 0x34, 0x34, 0x34, 0x32, 0x65, 0x32, 0x30, 0x33, 0x31, 0x33, 0x30, - 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x46, 0x69, 0x67, 0x68, 0x74, 0x69, - 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x65, 0x72, - 0x20, 0x33, 0x20, 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x34, 0x38, - 0x34, 0x66, 0x35, 0x32, 0x34, 0x39, 0x32, 0x30, 0x34, 0x33, 0x34, 0x66, - 0x32, 0x65, 0x32, 0x63, 0x34, 0x63, 0x35, 0x34, 0x34, 0x34, 0x32, 0x30, - 0x32, 0x30, 0x35, 0x30, 0x34, 0x31, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, - 0x47, 0x65, 0x6d, 0x20, 0x50, 0x61, 0x64, 0x20, 0x33, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x35, 0x36, 0x35, 0x36, - 0x34, 0x33, 0x36, 0x36, 0x34, 0x36, 0x36, 0x36, 0x31, 0x33, 0x31, 0x33, - 0x32, 0x33, 0x32, 0x36, 0x35, 0x36, 0x36, 0x36, 0x31, 0x36, 0x31, 0x36, - 0x31, 0x33, 0x30, 0x2c, 0x48, 0x6f, 0x72, 0x69, 0x20, 0x50, 0x43, 0x20, - 0x45, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x20, 0x4d, 0x69, 0x6e, 0x69, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, - 0x31, 0x33, 0x30, 0x33, 0x34, 0x33, 0x33, 0x33, 0x32, 0x36, 0x35, 0x36, - 0x32, 0x36, 0x33, 0x36, 0x34, 0x33, 0x31, 0x36, 0x35, 0x33, 0x35, 0x33, - 0x34, 0x36, 0x33, 0x36, 0x36, 0x33, 0x33, 0x2c, 0x48, 0x6f, 0x72, 0x69, - 0x20, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x41, 0x72, 0x63, 0x61, 0x64, 0x65, - 0x20, 0x50, 0x72, 0x6f, 0x20, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x33, 0x32, 0x36, 0x35, 0x36, 0x36, 0x36, 0x34, 0x33, 0x35, 0x33, - 0x39, 0x36, 0x34, 0x33, 0x39, 0x33, 0x35, 0x36, 0x31, 0x33, 0x36, 0x36, - 0x33, 0x36, 0x32, 0x33, 0x33, 0x33, 0x36, 0x33, 0x36, 0x2c, 0x48, 0x6f, - 0x72, 0x69, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x53, 0x70, - 0x6c, 0x69, 0x74, 0x20, 0x50, 0x61, 0x64, 0x20, 0x50, 0x72, 0x6f, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x33, 0x30, 0x33, 0x30, 0x36, 0x35, 0x33, 0x39, 0x33, - 0x35, 0x36, 0x32, 0x33, 0x38, 0x36, 0x35, 0x33, 0x36, 0x33, 0x37, 0x33, - 0x31, 0x33, 0x37, 0x33, 0x30, 0x36, 0x35, 0x36, 0x31, 0x33, 0x34, 0x2c, - 0x48, 0x4f, 0x52, 0x49, 0x50, 0x41, 0x44, 0x20, 0x53, 0x77, 0x69, 0x74, - 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, - 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x34, 0x38, 0x37, 0x39, 0x37, 0x30, 0x36, 0x35, 0x37, 0x32, 0x36, - 0x62, 0x36, 0x39, 0x36, 0x65, 0x32, 0x30, 0x35, 0x30, 0x36, 0x31, 0x36, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x48, 0x79, - 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x41, 0x64, 0x6d, 0x69, 0x72, - 0x61, 0x6c, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x62, 0x36, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x62, 0x37, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x62, 0x31, 0x37, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x62, 0x35, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x36, 0x32, 0x33, 0x33, 0x33, 0x33, 0x33, 0x31, 0x33, 0x35, 0x33, - 0x31, 0x33, 0x31, 0x33, 0x35, 0x33, 0x30, 0x33, 0x34, 0x33, 0x38, 0x36, - 0x31, 0x33, 0x36, 0x36, 0x32, 0x36, 0x36, 0x33, 0x36, 0x2c, 0x48, 0x79, - 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x41, 0x64, 0x6d, 0x69, 0x72, - 0x61, 0x6c, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x62, 0x36, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x62, 0x37, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x62, 0x31, 0x37, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x62, 0x35, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x33, 0x31, 0x33, 0x30, 0x36, 0x36, 0x33, 0x35, 0x33, 0x36, 0x33, - 0x35, 0x36, 0x32, 0x36, 0x36, 0x33, 0x38, 0x33, 0x34, 0x36, 0x33, 0x33, - 0x37, 0x33, 0x39, 0x33, 0x39, 0x36, 0x33, 0x33, 0x33, 0x2c, 0x48, 0x79, - 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x35, 0x33, 0x36, 0x38, 0x36, 0x31, 0x36, 0x65, 0x35, 0x37, 0x36, - 0x31, 0x36, 0x65, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, - 0x30, 0x34, 0x38, 0x37, 0x39, 0x37, 0x30, 0x36, 0x35, 0x2c, 0x48, 0x79, - 0x70, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x33, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x36, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x66, 0x66, 0x65, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x69, 0x42, - 0x75, 0x66, 0x66, 0x61, 0x6c, 0x6f, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, - 0x0d, 0x0a, 0x36, 0x34, 0x33, 0x30, 0x36, 0x31, 0x33, 0x37, 0x33, 0x36, - 0x33, 0x32, 0x36, 0x31, 0x33, 0x39, 0x36, 0x32, 0x36, 0x36, 0x33, 0x35, - 0x33, 0x34, 0x33, 0x33, 0x33, 0x30, 0x33, 0x35, 0x33, 0x31, 0x2c, 0x49, - 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x20, 0x47, 0x6f, 0x50, 0x61, - 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x79, 0x3a, - 0x62, 0x32, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, - 0x33, 0x32, 0x65, 0x35, 0x34, 0x32, 0x65, 0x34, 0x34, 0x32, 0x65, 0x32, - 0x30, 0x34, 0x39, 0x36, 0x65, 0x37, 0x34, 0x36, 0x35, 0x37, 0x32, 0x36, - 0x31, 0x36, 0x33, 0x37, 0x34, 0x32, 0x30, 0x2c, 0x49, 0x6e, 0x74, 0x65, - 0x72, 0x41, 0x63, 0x74, 0x20, 0x48, 0x61, 0x6d, 0x6d, 0x65, 0x72, 0x48, - 0x65, 0x61, 0x64, 0x20, 0x46, 0x58, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x33, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x33, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, - 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x33, 0x31, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x32, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, - 0x35, 0x33, 0x34, 0x36, 0x35, 0x33, 0x35, 0x36, 0x33, 0x36, 0x33, 0x33, - 0x33, 0x36, 0x36, 0x33, 0x39, 0x33, 0x31, 0x36, 0x31, 0x33, 0x32, 0x36, - 0x34, 0x36, 0x34, 0x33, 0x31, 0x36, 0x34, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, - 0x43, 0x6f, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x32, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x33, 0x33, 0x33, 0x34, 0x36, 0x35, 0x36, 0x36, 0x36, - 0x34, 0x33, 0x30, 0x33, 0x39, 0x33, 0x34, 0x33, 0x36, 0x33, 0x30, 0x33, - 0x37, 0x36, 0x35, 0x36, 0x35, 0x33, 0x32, 0x36, 0x33, 0x33, 0x35, 0x2c, - 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x4c, 0x29, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, - 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x35, 0x33, - 0x31, 0x33, 0x35, 0x33, 0x31, 0x36, 0x31, 0x33, 0x34, 0x33, 0x35, 0x36, - 0x32, 0x33, 0x33, 0x36, 0x36, 0x33, 0x31, 0x33, 0x38, 0x33, 0x35, 0x33, - 0x32, 0x36, 0x32, 0x33, 0x38, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, - 0x6e, 0x20, 0x28, 0x4c, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x34, 0x61, 0x36, 0x66, 0x37, 0x39, 0x32, 0x64, 0x34, - 0x33, 0x36, 0x66, 0x36, 0x65, 0x32, 0x30, 0x32, 0x38, 0x34, 0x63, 0x32, - 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x4c, 0x29, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, - 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, - 0x38, 0x33, 0x38, 0x33, 0x36, 0x36, 0x35, 0x36, 0x33, 0x33, 0x30, 0x33, - 0x39, 0x33, 0x36, 0x33, 0x30, 0x36, 0x36, 0x33, 0x38, 0x33, 0x33, 0x33, - 0x34, 0x36, 0x35, 0x33, 0x34, 0x36, 0x35, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, - 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x52, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, - 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x39, 0x33, 0x36, 0x33, 0x35, 0x36, - 0x31, 0x36, 0x31, 0x33, 0x39, 0x33, 0x36, 0x33, 0x30, 0x33, 0x32, 0x33, - 0x37, 0x33, 0x33, 0x33, 0x35, 0x33, 0x37, 0x33, 0x38, 0x33, 0x39, 0x33, - 0x31, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x52, - 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, - 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x34, - 0x61, 0x36, 0x66, 0x37, 0x39, 0x32, 0x64, 0x34, 0x33, 0x36, 0x66, 0x36, - 0x65, 0x32, 0x30, 0x32, 0x38, 0x35, 0x32, 0x32, 0x39, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4a, 0x6f, 0x79, 0x2d, - 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x52, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, - 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x39, 0x36, 0x35, 0x36, - 0x31, 0x33, 0x36, 0x33, 0x36, 0x33, 0x36, 0x33, 0x38, 0x33, 0x32, 0x33, - 0x30, 0x33, 0x36, 0x33, 0x30, 0x33, 0x38, 0x36, 0x35, 0x33, 0x32, 0x36, - 0x34, 0x36, 0x34, 0x2c, 0x4a, 0x59, 0x53, 0x20, 0x41, 0x61, 0x70, 0x74, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x36, 0x33, 0x33, 0x31, 0x36, 0x35, 0x36, 0x34, 0x33, 0x38, 0x33, - 0x35, 0x33, 0x39, 0x36, 0x36, 0x33, 0x31, 0x36, 0x36, 0x33, 0x35, 0x33, - 0x30, 0x33, 0x34, 0x36, 0x31, 0x36, 0x34, 0x33, 0x34, 0x2c, 0x4a, 0x59, - 0x53, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, - 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, - 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x34, 0x36, 0x32, 0x33, 0x31, - 0x36, 0x33, 0x33, 0x33, 0x33, 0x35, 0x36, 0x31, 0x36, 0x34, 0x33, 0x33, - 0x33, 0x39, 0x36, 0x32, 0x33, 0x32, 0x33, 0x35, 0x33, 0x37, 0x33, 0x32, - 0x33, 0x32, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, - 0x46, 0x33, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x35, - 0x36, 0x32, 0x33, 0x33, 0x36, 0x34, 0x33, 0x39, 0x33, 0x36, 0x36, 0x31, - 0x36, 0x32, 0x36, 0x32, 0x33, 0x31, 0x33, 0x34, 0x33, 0x38, 0x36, 0x36, - 0x36, 0x31, 0x33, 0x33, 0x33, 0x37, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, - 0x65, 0x63, 0x68, 0x20, 0x46, 0x37, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x34, 0x63, 0x36, 0x66, 0x36, 0x37, 0x36, 0x39, - 0x37, 0x34, 0x36, 0x35, 0x36, 0x33, 0x36, 0x38, 0x32, 0x30, 0x34, 0x37, - 0x36, 0x31, 0x36, 0x64, 0x36, 0x35, 0x37, 0x30, 0x36, 0x31, 0x36, 0x34, - 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x46, 0x37, - 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x34, 0x33, 0x39, - 0x36, 0x33, 0x33, 0x31, 0x33, 0x33, 0x33, 0x32, 0x33, 0x30, 0x33, 0x32, - 0x36, 0x33, 0x33, 0x33, 0x33, 0x31, 0x33, 0x33, 0x33, 0x30, 0x33, 0x33, - 0x36, 0x35, 0x33, 0x33, 0x2c, 0x4c, 0x6f, 0x67, 0x69, 0x74, 0x65, 0x63, - 0x68, 0x20, 0x46, 0x37, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x33, 0x39, 0x36, 0x35, 0x33, 0x33, 0x36, 0x35, 0x33, 0x37, 0x33, 0x38, - 0x36, 0x34, 0x36, 0x33, 0x33, 0x39, 0x33, 0x35, 0x33, 0x38, 0x33, 0x32, - 0x33, 0x36, 0x33, 0x36, 0x33, 0x34, 0x33, 0x38, 0x2c, 0x4c, 0x6f, 0x67, - 0x69, 0x74, 0x65, 0x63, 0x68, 0x20, 0x47, 0x20, 0x43, 0x6c, 0x6f, 0x75, - 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x7e, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x7e, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x34, 0x31, 0x36, 0x64, 0x36, - 0x31, 0x37, 0x61, 0x36, 0x66, 0x36, 0x65, 0x32, 0x30, 0x34, 0x37, 0x36, - 0x31, 0x36, 0x64, 0x36, 0x35, 0x32, 0x30, 0x34, 0x33, 0x36, 0x66, 0x36, - 0x65, 0x37, 0x34, 0x2c, 0x4c, 0x75, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x34, - 0x63, 0x37, 0x35, 0x36, 0x65, 0x36, 0x31, 0x32, 0x30, 0x34, 0x37, 0x36, - 0x31, 0x36, 0x64, 0x36, 0x35, 0x37, 0x30, 0x36, 0x31, 0x36, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4c, 0x75, 0x6e, 0x61, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x30, 0x33, 0x36, 0x33, 0x30, 0x36, - 0x36, 0x36, 0x32, 0x33, 0x35, 0x33, 0x39, 0x33, 0x32, 0x33, 0x35, 0x33, - 0x34, 0x33, 0x36, 0x33, 0x36, 0x33, 0x39, 0x33, 0x32, 0x33, 0x33, 0x36, - 0x33, 0x2c, 0x4d, 0x61, 0x67, 0x69, 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x31, 0x33, - 0x35, 0x33, 0x37, 0x36, 0x32, 0x33, 0x39, 0x33, 0x39, 0x33, 0x35, 0x33, - 0x38, 0x36, 0x36, 0x36, 0x32, 0x33, 0x33, 0x36, 0x33, 0x36, 0x35, 0x36, - 0x32, 0x36, 0x33, 0x33, 0x34, 0x2c, 0x4d, 0x61, 0x67, 0x69, 0x63, 0x20, - 0x4e, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x33, 0x39, 0x36, 0x32, 0x33, 0x35, 0x36, 0x35, 0x33, 0x34, 0x36, - 0x33, 0x36, 0x36, 0x36, 0x32, 0x33, 0x39, 0x33, 0x31, 0x36, 0x36, 0x36, - 0x36, 0x33, 0x33, 0x33, 0x32, 0x33, 0x35, 0x33, 0x30, 0x2c, 0x4d, 0x61, - 0x67, 0x69, 0x63, 0x20, 0x4e, 0x53, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x36, 0x64, 0x36, 0x31, 0x37, 0x39, 0x36, 0x36, 0x36, - 0x63, 0x36, 0x31, 0x37, 0x33, 0x36, 0x38, 0x32, 0x30, 0x36, 0x63, 0x36, - 0x39, 0x36, 0x64, 0x36, 0x39, 0x37, 0x34, 0x36, 0x35, 0x36, 0x34, 0x2c, - 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x47, 0x61, 0x6d, - 0x65, 0x43, 0x75, 0x62, 0x65, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x79, 0x3a, - 0x62, 0x32, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x34, - 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x66, 0x36, - 0x63, 0x36, 0x63, 0x36, 0x35, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x61, 0x79, 0x66, - 0x6c, 0x61, 0x73, 0x68, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x41, 0x64, 0x61, - 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x35, 0x36, 0x36, - 0x36, 0x33, 0x33, 0x30, 0x36, 0x33, 0x33, 0x38, 0x33, 0x38, 0x33, 0x38, - 0x33, 0x30, 0x36, 0x31, 0x33, 0x31, 0x33, 0x36, 0x33, 0x33, 0x33, 0x32, - 0x36, 0x34, 0x36, 0x31, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, - 0x68, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x39, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x37, 0x33, 0x31, 0x36, 0x35, 0x36, - 0x35, 0x33, 0x39, 0x36, 0x33, 0x36, 0x34, 0x33, 0x38, 0x36, 0x36, 0x33, - 0x35, 0x33, 0x38, 0x33, 0x32, 0x33, 0x30, 0x33, 0x35, 0x33, 0x33, 0x36, - 0x35, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x53, - 0x61, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x34, - 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, - 0x0d, 0x0a, 0x34, 0x38, 0x37, 0x35, 0x36, 0x39, 0x34, 0x61, 0x36, 0x39, - 0x36, 0x31, 0x32, 0x30, 0x32, 0x30, 0x35, 0x35, 0x35, 0x33, 0x34, 0x32, - 0x32, 0x30, 0x34, 0x37, 0x36, 0x31, 0x36, 0x64, 0x36, 0x35, 0x2c, 0x4d, - 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x53, 0x61, 0x74, 0x75, - 0x72, 0x6e, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x32, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x79, 0x3a, - 0x62, 0x32, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, - 0x33, 0x35, 0x61, 0x34, 0x64, 0x37, 0x39, 0x32, 0x64, 0x37, 0x30, 0x36, - 0x66, 0x37, 0x37, 0x36, 0x35, 0x37, 0x32, 0x32, 0x30, 0x34, 0x63, 0x35, - 0x34, 0x34, 0x34, 0x32, 0x30, 0x34, 0x33, 0x2c, 0x4d, 0x61, 0x79, 0x66, - 0x6c, 0x61, 0x73, 0x68, 0x20, 0x57, 0x69, 0x69, 0x20, 0x43, 0x6c, 0x61, - 0x73, 0x73, 0x69, 0x63, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x33, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x79, 0x3a, 0x62, - 0x32, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x30, - 0x36, 0x35, 0x33, 0x39, 0x36, 0x32, 0x36, 0x34, 0x33, 0x36, 0x36, 0x36, - 0x33, 0x30, 0x33, 0x36, 0x33, 0x31, 0x33, 0x37, 0x36, 0x34, 0x33, 0x38, - 0x33, 0x37, 0x33, 0x35, 0x33, 0x32, 0x2c, 0x4d, 0x61, 0x79, 0x66, 0x6c, - 0x61, 0x73, 0x68, 0x20, 0x57, 0x69, 0x69, 0x20, 0x44, 0x6f, 0x6c, 0x70, - 0x68, 0x69, 0x6e, 0x42, 0x61, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x33, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x32, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x33, 0x39, 0x33, 0x34, 0x36, 0x31, 0x33, 0x31, 0x33, - 0x39, 0x36, 0x32, 0x33, 0x33, 0x33, 0x37, 0x36, 0x35, 0x33, 0x35, 0x33, - 0x39, 0x33, 0x36, 0x36, 0x35, 0x33, 0x36, 0x33, 0x31, 0x36, 0x31, 0x2c, - 0x4d, 0x61, 0x79, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x20, 0x57, 0x69, 0x69, - 0x20, 0x55, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x33, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x79, - 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x33, 0x31, 0x33, 0x32, 0x33, 0x35, 0x36, 0x34, 0x36, 0x36, 0x33, 0x38, - 0x36, 0x32, 0x36, 0x33, 0x33, 0x32, 0x33, 0x34, 0x36, 0x34, 0x36, 0x33, - 0x33, 0x30, 0x33, 0x37, 0x33, 0x31, 0x33, 0x38, 0x2c, 0x4d, 0x65, 0x67, - 0x61, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, - 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x30, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x31, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x37, 0x33, 0x33, 0x33, - 0x35, 0x36, 0x34, 0x33, 0x39, 0x33, 0x32, 0x36, 0x31, 0x36, 0x35, 0x33, - 0x37, 0x33, 0x35, 0x33, 0x30, 0x36, 0x31, 0x33, 0x32, 0x36, 0x31, 0x33, - 0x30, 0x36, 0x31, 0x2c, 0x4d, 0x65, 0x67, 0x61, 0x20, 0x44, 0x72, 0x69, - 0x76, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x32, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x36, 0x34, 0x33, 0x36, 0x33, 0x33, 0x36, 0x33, 0x33, - 0x33, 0x36, 0x36, 0x33, 0x33, 0x33, 0x36, 0x33, 0x37, 0x33, 0x36, 0x33, - 0x39, 0x33, 0x30, 0x33, 0x38, 0x33, 0x31, 0x33, 0x34, 0x36, 0x34, 0x2c, - 0x4d, 0x65, 0x67, 0x61, 0x20, 0x44, 0x72, 0x69, 0x76, 0x65, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x33, - 0x33, 0x32, 0x33, 0x37, 0x36, 0x33, 0x33, 0x32, 0x33, 0x31, 0x33, 0x32, - 0x33, 0x37, 0x36, 0x35, 0x33, 0x37, 0x33, 0x37, 0x36, 0x32, 0x36, 0x36, - 0x33, 0x39, 0x33, 0x33, 0x36, 0x36, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, - 0x73, 0x6f, 0x66, 0x74, 0x20, 0x44, 0x75, 0x61, 0x6c, 0x20, 0x53, 0x74, - 0x72, 0x69, 0x6b, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, - 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x37, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x7e, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, - 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x30, 0x33, 0x30, 0x36, 0x34, - 0x36, 0x31, 0x36, 0x31, 0x33, 0x38, 0x33, 0x34, 0x33, 0x33, 0x33, 0x34, - 0x33, 0x39, 0x33, 0x30, 0x33, 0x37, 0x33, 0x34, 0x33, 0x31, 0x36, 0x35, - 0x33, 0x39, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, - 0x20, 0x53, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x20, - 0x50, 0x72, 0x6f, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x32, 0x33, 0x38, 0x36, - 0x32, 0x33, 0x35, 0x33, 0x35, 0x33, 0x36, 0x33, 0x30, 0x33, 0x39, 0x33, - 0x30, 0x33, 0x33, 0x33, 0x39, 0x33, 0x31, 0x33, 0x35, 0x36, 0x31, 0x33, - 0x38, 0x33, 0x31, 0x2c, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, - 0x74, 0x20, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, - 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x34, 0x64, 0x34, 0x66, 0x34, 0x33, 0x35, 0x35, 0x35, - 0x34, 0x34, 0x35, 0x32, 0x64, 0x33, 0x30, 0x33, 0x35, 0x33, 0x33, 0x35, - 0x38, 0x32, 0x64, 0x34, 0x64, 0x33, 0x35, 0x33, 0x31, 0x32, 0x64, 0x2c, - 0x4d, 0x6f, 0x63, 0x75, 0x74, 0x65, 0x20, 0x30, 0x35, 0x33, 0x58, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x33, 0x33, 0x33, 0x34, 0x33, 0x33, 0x36, 0x31, 0x33, - 0x37, 0x36, 0x31, 0x36, 0x33, 0x36, 0x32, 0x33, 0x34, 0x33, 0x38, 0x36, - 0x31, 0x33, 0x34, 0x36, 0x36, 0x36, 0x31, 0x36, 0x35, 0x33, 0x31, 0x2c, - 0x4d, 0x6f, 0x63, 0x75, 0x74, 0x65, 0x20, 0x4d, 0x30, 0x35, 0x33, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x39, 0x33, 0x30, - 0x36, 0x36, 0x33, 0x35, 0x36, 0x36, 0x33, 0x30, 0x36, 0x31, 0x36, 0x33, - 0x36, 0x35, 0x36, 0x33, 0x33, 0x31, 0x36, 0x31, 0x36, 0x36, 0x33, 0x30, - 0x33, 0x39, 0x36, 0x36, 0x2c, 0x4d, 0x6f, 0x63, 0x75, 0x74, 0x65, 0x20, - 0x4d, 0x30, 0x35, 0x33, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x37, 0x35, 0x37, 0x33, 0x36, 0x32, 0x32, 0x30, 0x36, 0x37, 0x36, - 0x31, 0x36, 0x64, 0x36, 0x35, 0x37, 0x30, 0x36, 0x31, 0x36, 0x34, 0x32, - 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x32, 0x30, 0x2c, 0x4e, 0x45, - 0x58, 0x54, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x36, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, - 0x66, 0x66, 0x66, 0x30, 0x66, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, - 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, - 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x34, 0x33, 0x32, 0x33, 0x34, 0x33, - 0x37, 0x33, 0x39, 0x36, 0x35, 0x33, 0x34, 0x36, 0x34, 0x33, 0x35, 0x33, - 0x31, 0x33, 0x32, 0x36, 0x31, 0x36, 0x31, 0x36, 0x33, 0x33, 0x37, 0x33, - 0x38, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, - 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, - 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6d, 0x69, 0x73, 0x63, - 0x31, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x30, 0x37, 0x32, 0x36, 0x66, 0x32, 0x30, - 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x66, - 0x36, 0x63, 0x36, 0x63, 0x36, 0x35, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, - 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x36, 0x33, 0x32, 0x36, - 0x35, 0x33, 0x33, 0x33, 0x35, 0x33, 0x31, 0x36, 0x36, 0x33, 0x32, 0x33, - 0x39, 0x36, 0x35, 0x36, 0x32, 0x33, 0x36, 0x36, 0x31, 0x33, 0x30, 0x33, - 0x39, 0x33, 0x33, 0x2c, 0x4e, 0x53, 0x4f, 0x20, 0x4e, 0x36, 0x34, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x2b, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x2b, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x2d, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x2d, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, - 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x34, 0x65, 0x33, 0x36, 0x33, 0x34, - 0x32, 0x30, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, - 0x36, 0x66, 0x36, 0x63, 0x36, 0x63, 0x36, 0x35, 0x37, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x4e, 0x53, 0x4f, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x2b, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x2b, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x2d, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x2d, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x33, 0x34, 0x65, 0x34, 0x35, 0x35, - 0x33, 0x32, 0x30, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, - 0x32, 0x36, 0x66, 0x36, 0x63, 0x36, 0x63, 0x36, 0x35, 0x37, 0x32, 0x30, - 0x30, 0x2c, 0x4e, 0x53, 0x4f, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, - 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, - 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, - 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x34, 0x36, 0x32, 0x33, 0x38, - 0x36, 0x33, 0x33, 0x34, 0x36, 0x31, 0x33, 0x33, 0x36, 0x33, 0x33, 0x35, - 0x36, 0x31, 0x36, 0x32, 0x36, 0x31, 0x33, 0x36, 0x33, 0x36, 0x36, 0x36, - 0x33, 0x34, 0x2c, 0x4e, 0x53, 0x4f, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, - 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x63, 0x66, 0x37, 0x66, 0x33, - 0x66, 0x30, 0x30, 0x2c, 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x37, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, - 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x35, 0x30, 0x39, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x34, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x64, - 0x66, 0x37, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x4e, 0x56, 0x49, 0x44, - 0x49, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x35, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x31, 0x34, 0x37, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x66, 0x37, 0x66, 0x33, 0x66, 0x38, 0x30, 0x2c, - 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x37, 0x33, 0x33, 0x36, - 0x34, 0x33, 0x35, 0x36, 0x36, 0x36, 0x33, 0x33, 0x38, 0x36, 0x35, 0x33, - 0x35, 0x36, 0x35, 0x33, 0x31, 0x33, 0x37, 0x33, 0x31, 0x33, 0x30, 0x33, - 0x38, 0x33, 0x34, 0x2c, 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x34, 0x65, 0x35, 0x36, 0x34, - 0x39, 0x34, 0x34, 0x34, 0x39, 0x34, 0x31, 0x32, 0x30, 0x34, 0x33, 0x36, - 0x66, 0x37, 0x32, 0x37, 0x30, 0x36, 0x66, 0x37, 0x32, 0x36, 0x31, 0x37, - 0x34, 0x36, 0x39, 0x2c, 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x31, 0x33, 0x36, 0x33, - 0x39, 0x33, 0x31, 0x36, 0x35, 0x36, 0x31, 0x33, 0x35, 0x33, 0x33, 0x36, - 0x31, 0x33, 0x30, 0x36, 0x36, 0x33, 0x35, 0x36, 0x31, 0x36, 0x31, 0x36, - 0x32, 0x36, 0x34, 0x2c, 0x4e, 0x56, 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x39, 0x33, 0x38, 0x33, - 0x33, 0x33, 0x35, 0x33, 0x31, 0x33, 0x34, 0x33, 0x38, 0x36, 0x32, 0x33, - 0x34, 0x33, 0x39, 0x33, 0x37, 0x33, 0x35, 0x33, 0x38, 0x33, 0x34, 0x33, - 0x32, 0x36, 0x36, 0x2c, 0x4f, 0x55, 0x59, 0x41, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x31, 0x36, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x78, 0x3a, 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, - 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x34, 0x66, 0x35, 0x35, 0x35, 0x39, - 0x34, 0x31, 0x32, 0x30, 0x34, 0x37, 0x36, 0x31, 0x36, 0x64, 0x36, 0x35, - 0x32, 0x30, 0x34, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, - 0x36, 0x66, 0x2c, 0x4f, 0x55, 0x59, 0x41, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x62, 0x31, 0x38, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x78, 0x3a, - 0x62, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x30, 0x36, 0x35, 0x37, 0x32, 0x36, 0x36, - 0x36, 0x66, 0x37, 0x32, 0x36, 0x64, 0x36, 0x31, 0x36, 0x65, 0x36, 0x33, - 0x36, 0x35, 0x32, 0x30, 0x34, 0x34, 0x36, 0x35, 0x37, 0x33, 0x36, 0x39, - 0x2c, 0x50, 0x44, 0x50, 0x20, 0x50, 0x53, 0x33, 0x20, 0x52, 0x6f, 0x63, - 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x32, 0x36, 0x35, 0x33, 0x33, 0x33, - 0x35, 0x33, 0x32, 0x36, 0x32, 0x36, 0x31, 0x33, 0x30, 0x33, 0x36, 0x36, - 0x33, 0x33, 0x35, 0x36, 0x32, 0x36, 0x33, 0x36, 0x32, 0x36, 0x33, 0x33, - 0x39, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x31, 0x39, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x33, 0x36, - 0x66, 0x36, 0x65, 0x37, 0x39, 0x32, 0x30, 0x34, 0x39, 0x36, 0x65, 0x37, - 0x34, 0x36, 0x35, 0x37, 0x32, 0x36, 0x31, 0x36, 0x33, 0x37, 0x34, 0x36, - 0x39, 0x37, 0x36, 0x36, 0x35, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, - 0x73, 0x63, 0x31, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x37, 0x36, 0x39, 0x37, 0x32, 0x36, - 0x35, 0x36, 0x63, 0x36, 0x35, 0x37, 0x33, 0x37, 0x33, 0x32, 0x30, 0x34, - 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x66, 0x36, - 0x63, 0x2c, 0x50, 0x6c, 0x61, 0x79, 0x53, 0x74, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x31, 0x36, 0x35, 0x33, 0x39, 0x36, 0x32, - 0x33, 0x35, 0x33, 0x32, 0x33, 0x32, 0x33, 0x36, 0x36, 0x31, 0x33, 0x30, - 0x33, 0x32, 0x36, 0x35, 0x33, 0x30, 0x33, 0x36, 0x33, 0x30, 0x36, 0x31, - 0x2c, 0x50, 0x6f, 0x6b, 0x6b, 0x65, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x33, 0x32, 0x36, 0x36, 0x36, 0x36, 0x33, 0x33, 0x36, 0x36, 0x33, 0x37, - 0x33, 0x35, 0x33, 0x35, 0x33, 0x32, 0x33, 0x34, 0x33, 0x36, 0x33, 0x30, - 0x36, 0x34, 0x33, 0x38, 0x36, 0x31, 0x33, 0x32, 0x2c, 0x50, 0x53, 0x32, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, - 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x79, - 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x36, 0x38, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x64, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x33, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x35, 0x33, 0x36, 0x66, 0x36, 0x65, 0x37, 0x39, 0x32, 0x30, 0x35, - 0x30, 0x34, 0x63, 0x34, 0x31, 0x35, 0x39, 0x35, 0x33, 0x35, 0x34, 0x34, - 0x31, 0x35, 0x34, 0x34, 0x39, 0x34, 0x66, 0x34, 0x65, 0x2c, 0x50, 0x53, - 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x36, 0x31, 0x33, 0x36, 0x33, 0x30, 0x33, 0x34, 0x36, 0x36, 0x33, 0x38, - 0x33, 0x39, 0x33, 0x37, 0x36, 0x36, 0x33, 0x38, 0x36, 0x35, 0x33, 0x34, - 0x36, 0x33, 0x36, 0x33, 0x33, 0x38, 0x36, 0x35, 0x2c, 0x50, 0x53, 0x33, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x61, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x36, 0x33, 0x36, 0x36, 0x35, 0x33, 0x39, - 0x36, 0x35, 0x36, 0x35, 0x36, 0x34, 0x36, 0x35, 0x33, 0x34, 0x33, 0x32, - 0x33, 0x35, 0x33, 0x31, 0x33, 0x39, 0x33, 0x35, 0x36, 0x35, 0x33, 0x36, - 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x36, 0x33, 0x38, 0x33, 0x31, 0x33, - 0x32, 0x33, 0x32, 0x36, 0x31, 0x36, 0x34, 0x36, 0x32, 0x36, 0x36, 0x33, - 0x36, 0x33, 0x31, 0x33, 0x37, 0x33, 0x37, 0x33, 0x37, 0x33, 0x30, 0x33, - 0x37, 0x2c, 0x50, 0x53, 0x33, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, - 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x34, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x33, 0x66, - 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x34, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x65, 0x33, 0x66, 0x30, 0x30, - 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, - 0x34, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x65, 0x33, - 0x66, 0x38, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x2b, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x34, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, - 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x63, 0x63, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x65, - 0x33, 0x66, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, - 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, - 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, - 0x30, 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x30, 0x33, 0x30, 0x33, 0x38, 0x33, 0x39, - 0x36, 0x36, 0x33, 0x33, 0x33, 0x30, 0x33, 0x34, 0x36, 0x36, 0x33, 0x32, - 0x33, 0x36, 0x33, 0x32, 0x33, 0x32, 0x36, 0x32, 0x33, 0x31, 0x33, 0x38, - 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, - 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x33, 0x31, 0x33, 0x32, 0x36, 0x32, 0x33, 0x35, 0x33, 0x38, 0x33, 0x36, - 0x36, 0x32, 0x33, 0x33, 0x33, 0x32, 0x36, 0x36, 0x36, 0x33, 0x33, 0x34, - 0x36, 0x33, 0x36, 0x35, 0x33, 0x33, 0x33, 0x32, 0x2c, 0x50, 0x53, 0x34, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x31, 0x33, 0x37, - 0x33, 0x32, 0x33, 0x31, 0x33, 0x33, 0x36, 0x35, 0x36, 0x31, 0x36, 0x33, - 0x36, 0x32, 0x33, 0x35, 0x36, 0x31, 0x33, 0x36, 0x36, 0x36, 0x33, 0x32, - 0x33, 0x30, 0x33, 0x35, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, - 0x31, 0x36, 0x36, 0x33, 0x38, 0x33, 0x38, 0x33, 0x33, 0x36, 0x33, 0x33, - 0x34, 0x33, 0x39, 0x33, 0x31, 0x33, 0x32, 0x33, 0x30, 0x33, 0x33, 0x33, - 0x38, 0x33, 0x35, 0x33, 0x39, 0x36, 0x33, 0x2c, 0x50, 0x53, 0x34, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x33, 0x34, 0x36, 0x31, 0x33, 0x31, 0x33, 0x39, 0x33, 0x37, 0x36, - 0x36, 0x33, 0x34, 0x36, 0x32, 0x36, 0x31, 0x33, 0x33, 0x33, 0x33, 0x36, - 0x35, 0x33, 0x30, 0x33, 0x38, 0x36, 0x34, 0x33, 0x30, 0x2c, 0x50, 0x53, - 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x35, 0x36, 0x34, 0x33, - 0x30, 0x33, 0x31, 0x33, 0x30, 0x33, 0x30, 0x33, 0x33, 0x33, 0x32, 0x36, - 0x31, 0x33, 0x30, 0x33, 0x31, 0x36, 0x33, 0x33, 0x30, 0x33, 0x35, 0x33, - 0x35, 0x36, 0x34, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x2b, 0x61, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x2b, - 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, - 0x0d, 0x0a, 0x33, 0x37, 0x36, 0x32, 0x36, 0x32, 0x33, 0x33, 0x33, 0x33, - 0x36, 0x32, 0x33, 0x35, 0x33, 0x34, 0x33, 0x39, 0x33, 0x37, 0x33, 0x33, - 0x33, 0x39, 0x36, 0x31, 0x33, 0x35, 0x33, 0x37, 0x33, 0x32, 0x2c, 0x50, - 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x37, 0x36, 0x32, - 0x36, 0x34, 0x36, 0x34, 0x33, 0x34, 0x33, 0x34, 0x33, 0x30, 0x36, 0x33, - 0x36, 0x35, 0x36, 0x32, 0x33, 0x31, 0x36, 0x36, 0x36, 0x31, 0x36, 0x34, - 0x33, 0x38, 0x36, 0x33, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, - 0x0d, 0x0a, 0x33, 0x38, 0x33, 0x39, 0x33, 0x31, 0x36, 0x31, 0x36, 0x33, - 0x36, 0x32, 0x36, 0x31, 0x36, 0x35, 0x33, 0x36, 0x33, 0x36, 0x36, 0x35, - 0x33, 0x35, 0x33, 0x32, 0x33, 0x38, 0x36, 0x36, 0x33, 0x39, 0x2c, 0x50, - 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x33, 0x33, 0x31, - 0x33, 0x37, 0x33, 0x33, 0x33, 0x39, 0x33, 0x35, 0x33, 0x35, 0x36, 0x36, - 0x33, 0x33, 0x33, 0x39, 0x36, 0x35, 0x36, 0x35, 0x36, 0x34, 0x33, 0x34, - 0x33, 0x39, 0x36, 0x32, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, - 0x0d, 0x0a, 0x36, 0x33, 0x33, 0x39, 0x33, 0x36, 0x36, 0x32, 0x33, 0x36, - 0x33, 0x38, 0x33, 0x36, 0x33, 0x38, 0x33, 0x34, 0x33, 0x39, 0x33, 0x35, - 0x33, 0x30, 0x36, 0x34, 0x36, 0x36, 0x33, 0x39, 0x33, 0x39, 0x2c, 0x50, - 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x35, 0x33, 0x36, 0x36, - 0x34, 0x36, 0x35, 0x36, 0x35, 0x36, 0x33, 0x36, 0x34, 0x36, 0x33, 0x36, - 0x31, 0x33, 0x37, 0x36, 0x35, 0x33, 0x33, 0x36, 0x33, 0x33, 0x37, 0x36, - 0x35, 0x33, 0x31, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x36, 0x36, 0x31, 0x33, 0x35, 0x33, - 0x32, 0x33, 0x30, 0x33, 0x39, 0x36, 0x35, 0x33, 0x38, 0x33, 0x35, 0x33, - 0x34, 0x33, 0x39, 0x36, 0x36, 0x33, 0x38, 0x36, 0x31, 0x33, 0x32, 0x33, - 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, - 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, - 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x65, 0x36, 0x30, 0x63, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x65, 0x33, 0x66, 0x30, 0x30, 0x2c, - 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x37, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x65, 0x36, 0x30, 0x63, - 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x65, 0x33, 0x66, 0x38, 0x30, - 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x36, 0x2c, - 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x65, 0x36, 0x30, - 0x63, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, - 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x33, 0x32, 0x33, 0x34, 0x36, 0x34, 0x36, 0x35, 0x33, - 0x34, 0x36, 0x35, 0x33, 0x33, 0x36, 0x31, 0x36, 0x32, 0x36, 0x33, 0x33, - 0x38, 0x36, 0x35, 0x33, 0x39, 0x33, 0x32, 0x33, 0x39, 0x33, 0x32, 0x2c, - 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, - 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x32, 0x36, 0x33, 0x33, 0x35, - 0x33, 0x32, 0x36, 0x34, 0x33, 0x37, 0x33, 0x34, 0x33, 0x37, 0x36, 0x36, - 0x33, 0x32, 0x36, 0x35, 0x36, 0x36, 0x36, 0x34, 0x33, 0x38, 0x33, 0x37, - 0x33, 0x33, 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x37, 0x33, 0x36, 0x33, 0x37, 0x36, 0x34, - 0x33, 0x35, 0x33, 0x37, 0x33, 0x31, 0x33, 0x32, 0x33, 0x39, 0x36, 0x33, - 0x33, 0x32, 0x33, 0x36, 0x33, 0x39, 0x36, 0x36, 0x36, 0x35, 0x36, 0x35, - 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, - 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, - 0x0d, 0x0a, 0x36, 0x31, 0x33, 0x30, 0x33, 0x31, 0x36, 0x32, 0x33, 0x35, - 0x33, 0x31, 0x36, 0x35, 0x33, 0x31, 0x36, 0x33, 0x36, 0x35, 0x33, 0x33, - 0x36, 0x34, 0x33, 0x36, 0x33, 0x34, 0x33, 0x31, 0x33, 0x39, 0x2c, 0x50, - 0x53, 0x35, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x39, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, - 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x34, 0x33, - 0x33, 0x36, 0x32, 0x36, 0x33, 0x33, 0x39, 0x33, 0x39, 0x33, 0x33, 0x36, - 0x32, 0x36, 0x35, 0x33, 0x35, 0x33, 0x30, 0x33, 0x33, 0x33, 0x39, 0x36, - 0x31, 0x36, 0x33, 0x33, 0x32, 0x2c, 0x51, 0x61, 0x6e, 0x62, 0x61, 0x20, - 0x34, 0x52, 0x41, 0x46, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, - 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, - 0x36, 0x36, 0x32, 0x36, 0x36, 0x36, 0x36, 0x33, 0x35, 0x33, 0x38, 0x36, - 0x31, 0x36, 0x36, 0x33, 0x38, 0x36, 0x34, 0x33, 0x33, 0x36, 0x31, 0x33, - 0x30, 0x33, 0x36, 0x33, 0x31, 0x33, 0x37, 0x2c, 0x52, 0x61, 0x7a, 0x65, - 0x72, 0x20, 0x4a, 0x75, 0x6e, 0x67, 0x6c, 0x65, 0x63, 0x61, 0x74, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x66, 0x38, 0x32, 0x37, 0x30, 0x30, 0x30, 0x30, 0x62, 0x66, 0x30, - 0x62, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, - 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x4b, 0x69, 0x73, 0x68, - 0x69, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x36, 0x32, 0x36, 0x35, 0x33, 0x38, 0x36, 0x31, 0x36, 0x34, 0x33, 0x33, - 0x33, 0x33, 0x36, 0x36, 0x33, 0x36, 0x36, 0x33, 0x33, 0x38, 0x33, 0x33, - 0x33, 0x32, 0x33, 0x39, 0x36, 0x36, 0x36, 0x35, 0x2c, 0x52, 0x61, 0x7a, - 0x65, 0x72, 0x20, 0x4b, 0x69, 0x73, 0x68, 0x69, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x66, - 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, - 0x72, 0x20, 0x52, 0x61, 0x69, 0x6a, 0x75, 0x20, 0x4d, 0x6f, 0x62, 0x69, - 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x30, 0x37, - 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, - 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, 0x52, 0x61, 0x69, 0x6a, 0x75, - 0x20, 0x4d, 0x6f, 0x62, 0x69, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x32, 0x31, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x39, 0x30, 0x30, 0x30, 0x30, 0x62, 0x66, 0x37, - 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x52, 0x61, 0x7a, 0x65, 0x72, 0x20, - 0x53, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, - 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, - 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x35, 0x61, 0x36, 0x38, 0x36, 0x39, 0x35, 0x38, 0x37, 0x35, 0x32, 0x30, - 0x35, 0x32, 0x36, 0x35, 0x37, 0x34, 0x37, 0x32, 0x36, 0x66, 0x32, 0x30, - 0x34, 0x32, 0x36, 0x39, 0x37, 0x34, 0x32, 0x30, 0x2c, 0x52, 0x65, 0x74, - 0x72, 0x6f, 0x20, 0x42, 0x69, 0x74, 0x20, 0x53, 0x61, 0x74, 0x75, 0x72, - 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x32, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x32, - 0x34, 0x31, 0x37, 0x38, 0x36, 0x35, 0x37, 0x33, 0x32, 0x30, 0x33, 0x31, - 0x33, 0x31, 0x34, 0x62, 0x36, 0x35, 0x37, 0x39, 0x37, 0x33, 0x32, 0x30, - 0x34, 0x37, 0x36, 0x31, 0x36, 0x64, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, - 0x20, 0x42, 0x69, 0x74, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, - 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, - 0x36, 0x33, 0x31, 0x33, 0x39, 0x33, 0x38, 0x33, 0x30, 0x36, 0x35, 0x33, - 0x39, 0x33, 0x32, 0x36, 0x32, 0x33, 0x33, 0x33, 0x39, 0x33, 0x37, 0x33, - 0x32, 0x36, 0x31, 0x33, 0x33, 0x36, 0x31, 0x2c, 0x52, 0x65, 0x74, 0x72, - 0x6f, 0x20, 0x42, 0x69, 0x74, 0x20, 0x53, 0x4e, 0x45, 0x53, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, - 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x35, 0x32, 0x36, 0x35, 0x37, 0x34, 0x37, 0x32, 0x36, 0x66, 0x34, 0x36, - 0x36, 0x63, 0x36, 0x31, 0x36, 0x37, 0x32, 0x30, 0x35, 0x37, 0x36, 0x39, - 0x37, 0x32, 0x36, 0x35, 0x36, 0x34, 0x32, 0x30, 0x2c, 0x52, 0x65, 0x74, - 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x31, 0x33, - 0x34, 0x33, 0x37, 0x33, 0x39, 0x33, 0x35, 0x33, 0x37, 0x36, 0x34, 0x33, - 0x36, 0x33, 0x31, 0x36, 0x35, 0x33, 0x34, 0x33, 0x32, 0x33, 0x37, 0x33, - 0x30, 0x33, 0x33, 0x33, 0x36, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, - 0x36, 0x35, 0x33, 0x31, 0x33, 0x30, 0x33, 0x37, 0x33, 0x33, 0x36, 0x35, - 0x36, 0x31, 0x33, 0x35, 0x33, 0x38, 0x33, 0x33, 0x33, 0x32, 0x33, 0x35, - 0x33, 0x30, 0x33, 0x30, 0x33, 0x36, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, - 0x69, 0x64, 0x20, 0x50, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x20, 0x32, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x34, 0x33, 0x36, 0x33, 0x33, 0x36, - 0x33, 0x33, 0x33, 0x36, 0x36, 0x33, 0x33, 0x33, 0x36, 0x33, 0x37, 0x33, - 0x36, 0x33, 0x39, 0x33, 0x30, 0x33, 0x38, 0x33, 0x31, 0x33, 0x34, 0x36, - 0x33, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x6b, 0x2c, - 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x36, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x37, - 0x33, 0x39, 0x33, 0x32, 0x33, 0x34, 0x33, 0x37, 0x33, 0x35, 0x33, 0x33, - 0x36, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x32, 0x33, 0x36, 0x33, 0x33, - 0x36, 0x34, 0x36, 0x35, 0x33, 0x31, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, - 0x55, 0x53, 0x42, 0x20, 0x4e, 0x36, 0x34, 0x20, 0x52, 0x65, 0x74, 0x72, - 0x6f, 0x50, 0x6f, 0x72, 0x74, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x62, 0x36, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, - 0x31, 0x39, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x30, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x33, 0x36, 0x35, 0x36, - 0x31, 0x36, 0x63, 0x36, 0x39, 0x36, 0x35, 0x34, 0x33, 0x36, 0x66, 0x36, - 0x64, 0x37, 0x30, 0x37, 0x35, 0x37, 0x34, 0x36, 0x39, 0x36, 0x65, 0x36, - 0x37, 0x32, 0x30, 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x55, 0x53, 0x42, - 0x20, 0x4e, 0x36, 0x34, 0x20, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x50, 0x6f, - 0x72, 0x74, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x62, - 0x31, 0x38, 0x2c, 0x2d, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x62, - 0x36, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x39, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x39, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x62, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x32, 0x36, 0x35, 0x37, 0x34, 0x37, 0x32, - 0x36, 0x66, 0x35, 0x35, 0x35, 0x33, 0x34, 0x32, 0x32, 0x65, 0x36, 0x33, - 0x36, 0x66, 0x36, 0x64, 0x32, 0x30, 0x35, 0x33, 0x34, 0x65, 0x34, 0x35, - 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x55, 0x53, 0x42, 0x20, 0x53, 0x4e, - 0x45, 0x53, 0x20, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x50, 0x6f, 0x72, 0x74, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x30, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x32, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x34, 0x36, 0x34, 0x33, 0x30, 0x33, 0x37, - 0x36, 0x33, 0x33, 0x30, 0x33, 0x38, 0x33, 0x38, 0x36, 0x32, 0x33, 0x38, - 0x33, 0x30, 0x33, 0x39, 0x36, 0x36, 0x33, 0x37, 0x36, 0x31, 0x33, 0x37, - 0x2c, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x55, 0x53, 0x42, 0x20, 0x53, 0x4e, - 0x45, 0x53, 0x20, 0x52, 0x65, 0x74, 0x72, 0x6f, 0x50, 0x6f, 0x72, 0x74, - 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x30, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x32, 0x2c, 0x78, - 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x37, 0x36, 0x35, 0x36, 0x35, 0x36, 0x34, - 0x33, 0x34, 0x36, 0x35, 0x33, 0x33, 0x36, 0x34, 0x33, 0x31, 0x33, 0x38, - 0x36, 0x33, 0x36, 0x34, 0x33, 0x36, 0x33, 0x35, 0x36, 0x32, 0x33, 0x30, - 0x2c, 0x52, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x20, - 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x37, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, 0x2c, 0x79, 0x3a, - 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x33, - 0x33, 0x37, 0x33, 0x33, 0x33, 0x36, 0x33, 0x39, 0x36, 0x36, 0x33, 0x34, - 0x33, 0x31, 0x36, 0x34, 0x33, 0x34, 0x33, 0x32, 0x33, 0x33, 0x33, 0x37, - 0x36, 0x36, 0x36, 0x33, 0x36, 0x31, 0x2c, 0x52, 0x75, 0x6d, 0x62, 0x6c, - 0x65, 0x50, 0x61, 0x64, 0x20, 0x32, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x32, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x32, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, - 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x36, 0x33, 0x36, 0x33, 0x35, - 0x33, 0x37, 0x33, 0x30, 0x33, 0x34, 0x33, 0x35, 0x33, 0x33, 0x33, 0x35, - 0x36, 0x36, 0x33, 0x38, 0x36, 0x36, 0x33, 0x38, 0x33, 0x36, 0x36, 0x33, - 0x33, 0x33, 0x2c, 0x53, 0x61, 0x6d, 0x73, 0x75, 0x6e, 0x67, 0x20, 0x45, - 0x49, 0x47, 0x50, 0x32, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, - 0x0d, 0x0a, 0x35, 0x33, 0x36, 0x31, 0x36, 0x64, 0x37, 0x33, 0x37, 0x35, - 0x36, 0x65, 0x36, 0x37, 0x32, 0x30, 0x34, 0x37, 0x36, 0x31, 0x36, 0x64, - 0x36, 0x35, 0x32, 0x30, 0x35, 0x30, 0x36, 0x31, 0x36, 0x34, 0x2c, 0x53, - 0x61, 0x6d, 0x73, 0x75, 0x6e, 0x67, 0x20, 0x45, 0x49, 0x47, 0x50, 0x32, - 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x36, - 0x33, 0x38, 0x36, 0x35, 0x36, 0x35, 0x33, 0x39, 0x36, 0x32, 0x33, 0x38, - 0x33, 0x36, 0x33, 0x35, 0x33, 0x34, 0x33, 0x31, 0x33, 0x38, 0x36, 0x33, - 0x33, 0x35, 0x33, 0x30, 0x36, 0x35, 0x2c, 0x53, 0x61, 0x6e, 0x77, 0x61, - 0x20, 0x50, 0x6c, 0x61, 0x79, 0x4f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x20, - 0x4d, 0x6f, 0x62, 0x69, 0x6c, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x31, - 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x32, 0x33, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, - 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x32, 0x33, 0x38, 0x33, 0x31, 0x36, 0x35, - 0x33, 0x31, 0x36, 0x33, 0x33, 0x33, 0x33, 0x38, 0x33, 0x37, 0x36, 0x36, - 0x33, 0x33, 0x36, 0x33, 0x33, 0x38, 0x33, 0x37, 0x33, 0x32, 0x36, 0x31, - 0x2c, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x36, 0x31, 0x33, 0x38, 0x36, - 0x35, 0x33, 0x39, 0x36, 0x35, 0x33, 0x30, 0x33, 0x35, 0x33, 0x33, 0x33, - 0x38, 0x33, 0x37, 0x33, 0x37, 0x36, 0x33, 0x36, 0x32, 0x33, 0x34, 0x33, - 0x31, 0x2c, 0x53, 0x61, 0x74, 0x75, 0x72, 0x6e, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x2b, 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x2d, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x2b, 0x61, 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x36, 0x31, 0x33, 0x31, 0x36, 0x32, 0x33, 0x32, 0x33, 0x33, 0x36, 0x32, - 0x36, 0x32, 0x33, 0x37, 0x33, 0x36, 0x33, 0x31, 0x33, 0x34, 0x33, 0x31, - 0x33, 0x37, 0x36, 0x33, 0x33, 0x36, 0x33, 0x31, 0x2c, 0x53, 0x61, 0x74, - 0x75, 0x72, 0x6e, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x33, 0x30, 0x33, 0x35, 0x33, 0x38, 0x33, 0x35, 0x33, 0x33, 0x33, - 0x33, 0x33, 0x38, 0x36, 0x31, 0x33, 0x31, 0x33, 0x30, 0x33, 0x37, 0x33, - 0x33, 0x36, 0x33, 0x36, 0x34, 0x36, 0x33, 0x33, 0x37, 0x2c, 0x53, 0x47, - 0x20, 0x48, 0x35, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, - 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x36, 0x36, 0x33, 0x38, 0x36, 0x32, 0x36, 0x32, 0x33, - 0x36, 0x36, 0x35, 0x33, 0x36, 0x36, 0x35, 0x33, 0x37, 0x36, 0x35, 0x33, - 0x33, 0x33, 0x32, 0x33, 0x35, 0x33, 0x34, 0x33, 0x36, 0x33, 0x34, 0x2c, - 0x53, 0x47, 0x20, 0x48, 0x35, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x36, 0x36, 0x33, 0x33, 0x31, 0x33, 0x32, - 0x33, 0x39, 0x33, 0x33, 0x36, 0x33, 0x33, 0x35, 0x33, 0x35, 0x33, 0x31, - 0x33, 0x37, 0x33, 0x34, 0x36, 0x35, 0x36, 0x33, 0x33, 0x30, 0x36, 0x34, - 0x2c, 0x53, 0x47, 0x20, 0x48, 0x35, 0x31, 0x30, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, - 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, - 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x32, 0x36, 0x35, 0x33, 0x37, - 0x36, 0x31, 0x36, 0x33, 0x36, 0x33, 0x36, 0x36, 0x33, 0x39, 0x33, 0x33, - 0x36, 0x36, 0x36, 0x31, 0x33, 0x31, 0x33, 0x35, 0x33, 0x36, 0x36, 0x33, - 0x33, 0x38, 0x2c, 0x53, 0x4e, 0x33, 0x30, 0x20, 0x50, 0x50, 0x2c, 0x61, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, - 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, - 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x33, 0x37, 0x36, - 0x36, 0x36, 0x32, 0x36, 0x36, 0x36, 0x36, 0x36, 0x31, 0x36, 0x33, 0x36, - 0x32, 0x36, 0x35, 0x33, 0x31, 0x33, 0x32, 0x36, 0x34, 0x36, 0x31, 0x33, - 0x30, 0x33, 0x39, 0x2c, 0x53, 0x4e, 0x45, 0x53, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, 0x61, - 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, 0x30, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, - 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x35, 0x33, 0x34, 0x36, 0x34, 0x33, 0x32, 0x66, 0x35, 0x35, 0x35, 0x33, - 0x34, 0x32, 0x32, 0x30, 0x35, 0x30, 0x36, 0x31, 0x36, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x4e, 0x45, - 0x53, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x2b, - 0x61, 0x31, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x2d, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x2b, 0x61, - 0x30, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x2d, 0x61, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, - 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x35, 0x35, 0x35, 0x33, 0x34, 0x32, 0x32, 0x30, 0x34, 0x37, 0x36, - 0x31, 0x36, 0x64, 0x36, 0x35, 0x37, 0x30, 0x36, 0x31, 0x36, 0x34, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x4e, - 0x45, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x33, 0x33, 0x30, - 0x33, 0x39, 0x36, 0x34, 0x33, 0x30, 0x33, 0x34, 0x36, 0x32, 0x33, 0x36, - 0x36, 0x31, 0x33, 0x36, 0x36, 0x31, 0x36, 0x32, 0x36, 0x36, 0x36, 0x35, - 0x33, 0x35, 0x36, 0x31, 0x2c, 0x53, 0x6f, 0x6e, 0x79, 0x20, 0x50, 0x53, - 0x50, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x32, - 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x32, 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x32, 0x38, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x34, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x33, 0x33, 0x37, - 0x36, 0x36, 0x33, 0x37, 0x36, 0x34, 0x33, 0x34, 0x36, 0x32, 0x33, 0x34, - 0x33, 0x37, 0x36, 0x36, 0x33, 0x33, 0x33, 0x34, 0x36, 0x32, 0x33, 0x38, - 0x33, 0x32, 0x33, 0x35, 0x2c, 0x53, 0x6f, 0x6e, 0x79, 0x20, 0x56, 0x69, - 0x74, 0x61, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x39, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x30, - 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x34, 0x37, 0x36, 0x66, 0x36, 0x66, 0x36, 0x37, 0x36, 0x63, 0x36, - 0x35, 0x32, 0x30, 0x34, 0x63, 0x34, 0x63, 0x34, 0x33, 0x32, 0x30, 0x35, - 0x33, 0x37, 0x34, 0x36, 0x31, 0x36, 0x34, 0x36, 0x39, 0x2c, 0x53, 0x74, - 0x61, 0x64, 0x69, 0x61, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x33, 0x37, 0x34, 0x36, - 0x31, 0x36, 0x34, 0x36, 0x39, 0x36, 0x31, 0x34, 0x65, 0x33, 0x38, 0x34, - 0x38, 0x35, 0x33, 0x32, 0x64, 0x36, 0x35, 0x33, 0x32, 0x36, 0x33, 0x33, - 0x34, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x61, 0x64, 0x69, 0x61, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, - 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, - 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x31, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, - 0x74, 0x65, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x36, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, - 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x31, 0x34, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x37, 0x65, 0x30, 0x66, 0x30, 0x30, 0x2c, 0x53, - 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x4e, - 0x69, 0x6d, 0x62, 0x75, 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x78, - 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x35, 0x33, 0x30, 0x36, 0x34, 0x33, - 0x36, 0x33, 0x39, 0x36, 0x34, 0x33, 0x37, 0x33, 0x37, 0x33, 0x31, 0x33, - 0x35, 0x33, 0x38, 0x33, 0x36, 0x36, 0x35, 0x36, 0x34, 0x36, 0x34, 0x36, - 0x34, 0x2c, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x53, 0x65, 0x72, 0x69, 0x65, - 0x73, 0x20, 0x4e, 0x69, 0x6d, 0x62, 0x75, 0x73, 0x20, 0x50, 0x6c, 0x75, - 0x73, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x39, 0x2c, - 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x35, 0x34, 0x34, 0x37, 0x35, 0x61, 0x32, 0x30, 0x34, 0x33, 0x36, 0x66, - 0x36, 0x65, 0x37, 0x34, 0x37, 0x32, 0x36, 0x66, 0x36, 0x63, 0x36, 0x63, - 0x36, 0x35, 0x37, 0x32, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x54, 0x47, 0x5a, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x32, 0x33, 0x36, - 0x33, 0x34, 0x33, 0x34, 0x33, 0x35, 0x33, 0x35, 0x33, 0x32, 0x33, 0x38, - 0x36, 0x32, 0x33, 0x38, 0x33, 0x33, 0x36, 0x36, 0x36, 0x33, 0x36, 0x34, - 0x33, 0x38, 0x33, 0x36, 0x2c, 0x54, 0x47, 0x5a, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x37, 0x33, 0x32, 0x33, 0x32, 0x33, 0x36, - 0x36, 0x33, 0x33, 0x37, 0x36, 0x33, 0x36, 0x36, 0x36, 0x34, 0x36, 0x35, - 0x33, 0x31, 0x36, 0x33, 0x36, 0x35, 0x33, 0x31, 0x33, 0x32, 0x33, 0x36, - 0x2c, 0x54, 0x48, 0x45, 0x43, 0x36, 0x34, 0x20, 0x4a, 0x6f, 0x79, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, - 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x33, 0x38, 0x33, 0x34, 0x36, 0x31, 0x36, 0x32, 0x33, 0x32, 0x36, 0x32, - 0x33, 0x32, 0x33, 0x34, 0x36, 0x35, 0x33, 0x33, 0x33, 0x31, 0x36, 0x31, - 0x36, 0x34, 0x33, 0x36, 0x33, 0x33, 0x33, 0x36, 0x2c, 0x54, 0x48, 0x45, - 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, - 0x66, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x64, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x65, 0x33, 0x66, 0x30, 0x30, 0x2c, - 0x54, 0x68, 0x72, 0x75, 0x73, 0x74, 0x4d, 0x61, 0x73, 0x74, 0x65, 0x72, - 0x20, 0x65, 0x53, 0x77, 0x61, 0x70, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x34, 0x37, - 0x37, 0x36, 0x39, 0x36, 0x65, 0x32, 0x30, 0x35, 0x35, 0x35, 0x33, 0x34, - 0x32, 0x32, 0x30, 0x34, 0x61, 0x36, 0x66, 0x37, 0x39, 0x37, 0x33, 0x37, - 0x34, 0x36, 0x39, 0x36, 0x33, 0x2c, 0x54, 0x77, 0x69, 0x6e, 0x20, 0x4a, - 0x6f, 0x79, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x2c, 0x61, 0x3a, 0x62, 0x32, - 0x32, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x32, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x32, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x33, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x32, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x32, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x79, - 0x3a, 0x62, 0x32, 0x30, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x33, 0x30, 0x36, 0x32, 0x33, 0x37, 0x33, 0x39, 0x33, 0x34, 0x33, 0x30, - 0x33, 0x39, 0x36, 0x34, 0x33, 0x38, 0x33, 0x30, 0x33, 0x33, 0x33, 0x32, - 0x36, 0x36, 0x33, 0x34, 0x36, 0x34, 0x33, 0x39, 0x2c, 0x56, 0x61, 0x6c, - 0x76, 0x65, 0x20, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x70, 0x61, - 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x70, 0x61, - 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x31, 0x36, 0x34, 0x33, 0x33, 0x36, 0x35, - 0x36, 0x36, 0x36, 0x34, 0x33, 0x32, 0x33, 0x38, 0x36, 0x31, 0x33, 0x33, - 0x33, 0x34, 0x36, 0x36, 0x33, 0x39, 0x33, 0x38, 0x33, 0x39, 0x33, 0x37, - 0x2c, 0x56, 0x61, 0x6c, 0x76, 0x65, 0x20, 0x53, 0x74, 0x65, 0x61, 0x6d, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x32, - 0x34, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x32, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x30, 0x33, 0x38, - 0x36, 0x34, 0x33, 0x38, 0x33, 0x31, 0x33, 0x35, 0x36, 0x34, 0x33, 0x30, - 0x36, 0x31, 0x36, 0x31, 0x33, 0x39, 0x33, 0x35, 0x33, 0x37, 0x33, 0x33, - 0x33, 0x36, 0x36, 0x33, 0x2c, 0x57, 0x69, 0x69, 0x20, 0x43, 0x6c, 0x61, - 0x73, 0x73, 0x69, 0x63, 0x20, 0x41, 0x64, 0x61, 0x70, 0x74, 0x65, 0x72, - 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x32, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, 0x39, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, - 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x34, 0x2c, 0x79, - 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x33, 0x33, 0x33, 0x33, 0x33, 0x30, 0x33, 0x34, 0x36, 0x34, 0x36, 0x33, - 0x33, 0x36, 0x33, 0x34, 0x36, 0x33, 0x33, 0x39, 0x36, 0x34, 0x36, 0x35, - 0x33, 0x38, 0x36, 0x34, 0x33, 0x36, 0x33, 0x33, 0x2c, 0x57, 0x69, 0x69, - 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x20, 0x41, 0x64, 0x61, - 0x70, 0x74, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x32, 0x33, 0x2c, 0x62, - 0x3a, 0x62, 0x32, 0x32, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x32, - 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x32, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x35, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x32, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x62, - 0x32, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x33, 0x30, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x34, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x31, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x38, 0x65, 0x30, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x33, 0x66, 0x30, 0x30, - 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x30, 0x33, 0x39, 0x36, - 0x32, 0x33, 0x32, 0x33, 0x39, 0x33, 0x31, 0x36, 0x32, 0x33, 0x34, 0x36, - 0x33, 0x33, 0x30, 0x33, 0x32, 0x36, 0x33, 0x33, 0x34, 0x36, 0x33, 0x36, - 0x35, 0x36, 0x36, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, - 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x33, 0x38, 0x33, 0x31, 0x33, 0x30, - 0x33, 0x38, 0x33, 0x32, 0x33, 0x37, 0x33, 0x30, 0x33, 0x38, 0x33, 0x38, - 0x36, 0x34, 0x36, 0x36, 0x36, 0x34, 0x36, 0x33, 0x33, 0x38, 0x33, 0x35, - 0x33, 0x33, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x35, 0x38, 0x36, 0x32, 0x36, 0x66, 0x37, - 0x38, 0x32, 0x30, 0x33, 0x33, 0x33, 0x36, 0x33, 0x30, 0x32, 0x30, 0x35, - 0x37, 0x36, 0x39, 0x37, 0x32, 0x36, 0x35, 0x36, 0x63, 0x36, 0x35, 0x37, - 0x33, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x36, 0x35, 0x33, 0x35, 0x33, 0x33, 0x33, 0x31, 0x33, 0x38, 0x36, - 0x36, 0x36, 0x32, 0x33, 0x34, 0x33, 0x33, 0x33, 0x38, 0x36, 0x34, 0x33, - 0x39, 0x33, 0x39, 0x36, 0x34, 0x33, 0x36, 0x33, 0x36, 0x2c, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x36, 0x35, 0x36, 0x31, 0x33, 0x35, 0x33, 0x32, 0x33, 0x38, 0x36, 0x36, - 0x33, 0x33, 0x33, 0x37, 0x33, 0x39, 0x36, 0x33, 0x36, 0x31, 0x36, 0x34, - 0x36, 0x32, 0x33, 0x36, 0x33, 0x30, 0x33, 0x38, 0x2c, 0x58, 0x62, 0x6f, - 0x78, 0x20, 0x33, 0x36, 0x30, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x34, - 0x37, 0x36, 0x35, 0x36, 0x65, 0x36, 0x35, 0x37, 0x32, 0x36, 0x39, 0x36, - 0x33, 0x32, 0x30, 0x35, 0x38, 0x32, 0x64, 0x34, 0x32, 0x36, 0x66, 0x37, - 0x38, 0x32, 0x30, 0x37, 0x30, 0x36, 0x31, 0x2c, 0x58, 0x62, 0x6f, 0x78, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x34, 0x64, 0x36, 0x39, 0x36, 0x33, 0x37, 0x32, 0x36, - 0x66, 0x37, 0x33, 0x36, 0x66, 0x36, 0x36, 0x37, 0x34, 0x32, 0x30, 0x35, - 0x38, 0x32, 0x64, 0x34, 0x32, 0x36, 0x66, 0x37, 0x38, 0x32, 0x30, 0x2c, - 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x36, 0x34, 0x36, 0x33, 0x33, - 0x34, 0x33, 0x36, 0x33, 0x31, 0x33, 0x39, 0x36, 0x35, 0x36, 0x35, 0x36, - 0x36, 0x36, 0x34, 0x33, 0x37, 0x33, 0x36, 0x33, 0x34, 0x33, 0x32, 0x33, - 0x33, 0x36, 0x34, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x39, 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x66, - 0x66, 0x30, 0x37, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, - 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x39, - 0x31, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x37, 0x33, - 0x66, 0x38, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, - 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x32, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x65, 0x33, 0x66, 0x30, 0x30, 0x2c, - 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x37, - 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, - 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x66, 0x66, 0x65, 0x33, 0x66, 0x38, 0x30, 0x2c, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x79, - 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, - 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x66, - 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, - 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, - 0x62, 0x31, 0x37, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, - 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x38, 0x30, - 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x39, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x31, 0x37, 0x2c, 0x79, 0x3a, 0x62, - 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x66, 0x64, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, - 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, - 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x33, 0x33, 0x33, 0x35, 0x36, 0x36, 0x36, 0x31, 0x33, - 0x32, 0x33, 0x32, 0x36, 0x36, 0x33, 0x33, 0x33, 0x37, 0x33, 0x33, 0x33, - 0x37, 0x33, 0x38, 0x36, 0x35, 0x36, 0x35, 0x36, 0x33, 0x36, 0x36, 0x2c, - 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x33, 0x34, 0x33, 0x35, 0x36, 0x31, 0x33, 0x36, 0x36, 0x33, 0x33, - 0x33, 0x36, 0x36, 0x36, 0x31, 0x33, 0x35, 0x33, 0x30, 0x33, 0x31, 0x36, - 0x33, 0x33, 0x38, 0x33, 0x37, 0x36, 0x31, 0x33, 0x36, 0x2c, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x33, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x31, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x36, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x78, 0x3a, 0x62, - 0x31, 0x37, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, - 0x2c, 0x0d, 0x0a, 0x33, 0x35, 0x36, 0x32, 0x33, 0x39, 0x36, 0x35, 0x33, - 0x37, 0x33, 0x32, 0x36, 0x34, 0x33, 0x38, 0x36, 0x32, 0x33, 0x38, 0x33, - 0x35, 0x33, 0x34, 0x33, 0x33, 0x36, 0x35, 0x36, 0x31, 0x33, 0x38, 0x2c, - 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x33, 0x36, 0x36, 0x31, 0x36, 0x31, 0x33, 0x31, 0x36, 0x34, 0x33, - 0x33, 0x36, 0x31, 0x33, 0x33, 0x33, 0x33, 0x33, 0x37, 0x33, 0x39, 0x36, - 0x32, 0x36, 0x31, 0x36, 0x36, 0x36, 0x34, 0x33, 0x33, 0x2c, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x35, 0x38, 0x36, 0x32, 0x36, 0x66, 0x37, 0x38, 0x32, 0x30, 0x35, - 0x37, 0x36, 0x39, 0x37, 0x32, 0x36, 0x35, 0x36, 0x63, 0x36, 0x35, 0x37, - 0x33, 0x37, 0x33, 0x32, 0x30, 0x34, 0x33, 0x36, 0x66, 0x2c, 0x58, 0x62, - 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x31, 0x35, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, - 0x38, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, - 0x6e, 0x65, 0x20, 0x45, 0x6c, 0x69, 0x74, 0x65, 0x20, 0x32, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, - 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, - 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, - 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, - 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, - 0x33, 0x66, 0x38, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, - 0x65, 0x20, 0x45, 0x6c, 0x69, 0x74, 0x65, 0x20, 0x32, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, - 0x66, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, - 0x20, 0x45, 0x6c, 0x69, 0x74, 0x65, 0x20, 0x32, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x36, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, - 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, - 0x30, 0x65, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, - 0x38, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, - 0x6e, 0x65, 0x20, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, - 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, - 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, - 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x61, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x53, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, - 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, - 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x66, - 0x64, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x37, 0x66, 0x33, - 0x66, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, - 0x20, 0x53, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x37, 0x38, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, - 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, - 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x32, - 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x38, 0x33, 0x66, - 0x38, 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, - 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, 0x0a, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, - 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, - 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x6e, - 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, - 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, - 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, - 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, - 0x0d, 0x0a, 0x36, 0x35, 0x36, 0x33, 0x33, 0x30, 0x33, 0x38, 0x33, 0x36, - 0x33, 0x38, 0x33, 0x32, 0x33, 0x35, 0x33, 0x36, 0x33, 0x34, 0x36, 0x35, - 0x33, 0x38, 0x33, 0x36, 0x33, 0x39, 0x36, 0x32, 0x33, 0x39, 0x2c, 0x58, - 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x31, 0x35, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x35, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x32, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x33, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, 0x3a, 0x62, 0x32, - 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2c, 0x0d, - 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x37, 0x32, - 0x37, 0x30, 0x30, 0x30, 0x30, 0x34, 0x34, 0x33, 0x31, 0x30, 0x30, 0x30, - 0x30, 0x66, 0x66, 0x66, 0x66, 0x33, 0x66, 0x30, 0x30, 0x2c, 0x58, 0x69, - 0x61, 0x6f, 0x4d, 0x69, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x34, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x37, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x31, 0x30, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x61, 0x32, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, - 0x61, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x41, 0x6e, 0x64, 0x72, 0x6f, - 0x69, 0x64, 0x2c, 0x0d, 0x0a, 0x0d, 0x0a, 0x23, 0x20, 0x69, 0x4f, 0x53, - 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x31, 0x2c, 0x2a, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, - 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x34, 0x66, 0x30, 0x36, 0x36, 0x64, 0x30, 0x31, 0x2c, 0x2a, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, - 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x63, 0x66, 0x30, 0x37, 0x36, 0x64, 0x30, 0x31, 0x2c, 0x2a, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, - 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x66, 0x30, 0x37, 0x36, 0x64, 0x30, - 0x31, 0x2c, 0x2a, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, - 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x37, 0x36, 0x64, 0x30, 0x31, - 0x2c, 0x2a, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, - 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x64, 0x30, 0x32, 0x2c, 0x2a, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, - 0x64, 0x65, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, - 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x36, 0x36, 0x64, 0x30, 0x32, - 0x2c, 0x2a, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x38, 0x61, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x33, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x37, 0x30, - 0x30, 0x30, 0x30, 0x2c, 0x42, 0x61, 0x63, 0x6b, 0x62, 0x6f, 0x6e, 0x65, - 0x20, 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, - 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, - 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x38, 0x61, 0x33, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, - 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x37, 0x30, 0x30, - 0x30, 0x30, 0x2c, 0x42, 0x61, 0x63, 0x6b, 0x62, 0x6f, 0x6e, 0x65, 0x20, - 0x4f, 0x6e, 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, - 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, - 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, - 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, - 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, - 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, - 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x34, 0x64, 0x34, 0x36, 0x36, 0x39, 0x34, - 0x37, 0x36, 0x31, 0x36, 0x64, 0x36, 0x35, 0x37, 0x30, 0x36, 0x31, 0x36, - 0x34, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4d, 0x46, 0x69, 0x20, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, - 0x65, 0x64, 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, - 0x34, 0x64, 0x34, 0x36, 0x36, 0x39, 0x34, 0x37, 0x36, 0x31, 0x36, 0x64, - 0x36, 0x35, 0x37, 0x30, 0x36, 0x31, 0x36, 0x34, 0x30, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4d, 0x46, 0x69, - 0x20, 0x47, 0x61, 0x6d, 0x65, 0x70, 0x61, 0x64, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, - 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, - 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, - 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x35, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x36, 0x2c, - 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, - 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, - 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x66, 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, - 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, - 0x68, 0x20, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x4c, - 0x29, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x2b, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, - 0x34, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, - 0x38, 0x2c, 0x2d, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x78, 0x3a, 0x62, - 0x31, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, - 0x30, 0x36, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, - 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x4a, - 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x4c, 0x29, 0x2c, 0x2b, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x2b, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x2d, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x2d, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x62, 0x32, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x62, 0x30, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x3a, 0x62, 0x33, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x62, - 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, - 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, - 0x62, 0x36, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x38, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, - 0x66, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, - 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, - 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, 0x4c, 0x2f, 0x52, - 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, - 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x65, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x32, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x64, 0x66, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x4e, - 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, 0x74, - 0x63, 0x68, 0x20, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, 0x6e, 0x20, 0x28, - 0x4c, 0x2f, 0x52, 0x29, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, - 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x66, 0x30, 0x36, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, - 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x4a, 0x6f, 0x79, 0x2d, 0x43, 0x6f, - 0x6e, 0x20, 0x28, 0x52, 0x29, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x2b, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x2d, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x78, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x2d, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x79, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x61, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, 0x32, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, - 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, - 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x64, 0x66, 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, 0x2c, - 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, 0x77, 0x69, - 0x74, 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x33, 0x2c, 0x79, 0x3a, 0x62, - 0x32, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, - 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x37, 0x65, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x32, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x38, 0x37, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x4e, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x6f, 0x20, 0x53, - 0x77, 0x69, 0x74, 0x63, 0x68, 0x20, 0x50, 0x72, 0x6f, 0x20, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, - 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, - 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, - 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, - 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, - 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x39, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, - 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, - 0x39, 0x30, 0x30, 0x30, 0x30, 0x64, 0x66, 0x30, 0x37, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, - 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, - 0x39, 0x30, 0x30, 0x30, 0x30, 0x64, 0x66, 0x38, 0x37, 0x30, 0x30, 0x30, - 0x31, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, - 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, - 0x39, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x37, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, - 0x69, 0x64, 0x65, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, - 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, - 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, - 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, - 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, 0x39, 0x30, - 0x30, 0x30, 0x30, 0x66, 0x66, 0x38, 0x37, 0x30, 0x30, 0x30, 0x31, 0x2c, - 0x50, 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, - 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, - 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, - 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, - 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, - 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, - 0x65, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, - 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, - 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, - 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, - 0x74, 0x6f, 0x75, 0x63, 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, 0x31, 0x31, - 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, - 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x63, 0x63, 0x30, 0x39, 0x30, 0x30, - 0x30, 0x30, 0x66, 0x66, 0x38, 0x37, 0x36, 0x64, 0x30, 0x31, 0x2c, 0x50, - 0x53, 0x34, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x65, 0x36, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x64, 0x66, - 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, - 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x74, 0x6f, 0x75, - 0x63, 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, - 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, - 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, - 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x63, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x65, 0x36, 0x30, 0x63, 0x30, 0x30, 0x30, 0x30, 0x66, - 0x66, 0x38, 0x37, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x50, 0x53, 0x35, 0x20, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, - 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, - 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, - 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, - 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x39, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x74, 0x6f, 0x75, 0x63, - 0x68, 0x70, 0x61, 0x64, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x36, 0x64, 0x30, 0x33, 0x2c, 0x52, 0x65, 0x6d, 0x6f, 0x74, - 0x65, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, - 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x63, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x33, 0x30, - 0x30, 0x36, 0x64, 0x30, 0x33, 0x2c, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, - 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x38, - 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, - 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x33, 0x2c, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x64, 0x65, 0x32, 0x38, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x36, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x53, 0x74, 0x65, 0x61, 0x6d, - 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, - 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, - 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, - 0x62, 0x38, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, - 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, - 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, - 0x33, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x37, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, - 0x64, 0x66, 0x30, 0x37, 0x30, 0x30, 0x30, 0x31, 0x2c, 0x58, 0x62, 0x6f, - 0x78, 0x20, 0x45, 0x6c, 0x69, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, - 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, - 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, - 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, - 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, - 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, - 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x31, 0x3a, 0x62, 0x31, - 0x30, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x32, 0x3a, 0x62, 0x31, - 0x32, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x33, 0x3a, 0x62, 0x31, - 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x34, 0x3a, 0x62, 0x31, - 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, - 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, - 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x37, 0x30, - 0x30, 0x30, 0x31, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x45, 0x6c, 0x69, - 0x74, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, - 0x31, 0x3a, 0x62, 0x31, 0x31, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, - 0x32, 0x3a, 0x62, 0x31, 0x33, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, - 0x33, 0x3a, 0x62, 0x31, 0x32, 0x2c, 0x70, 0x61, 0x64, 0x64, 0x6c, 0x65, - 0x34, 0x3a, 0x62, 0x31, 0x34, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, - 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, - 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, - 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, - 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, - 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, - 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, - 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, - 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, 0x32, 0x30, 0x30, 0x30, 0x30, - 0x64, 0x66, 0x30, 0x37, 0x30, 0x30, 0x30, 0x30, 0x2c, 0x58, 0x62, 0x6f, - 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, - 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, - 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, - 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, - 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, - 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, - 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, 0x65, - 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, - 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, - 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, - 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, - 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, - 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, - 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, - 0x3a, 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, - 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, - 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x65, 0x30, 0x30, - 0x32, 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x30, 0x37, 0x30, 0x30, 0x30, - 0x30, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x4f, 0x6e, 0x65, 0x20, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, - 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, - 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, - 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, - 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, - 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, - 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, 0x3a, 0x62, 0x39, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, - 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, - 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, - 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, - 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, - 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, - 0x31, 0x33, 0x30, 0x62, 0x30, 0x30, 0x30, 0x30, 0x64, 0x66, 0x38, 0x37, - 0x30, 0x30, 0x30, 0x31, 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, - 0x72, 0x69, 0x65, 0x73, 0x20, 0x58, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, - 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, - 0x3a, 0x62, 0x31, 0x2c, 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, - 0x64, 0x70, 0x64, 0x6f, 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, - 0x64, 0x70, 0x6c, 0x65, 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, - 0x64, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, - 0x2c, 0x64, 0x70, 0x75, 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x6c, - 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, - 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, - 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x74, 0x72, 0x69, 0x67, - 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x78, - 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x79, 0x3a, 0x61, 0x31, - 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, - 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x74, 0x69, - 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x74, - 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x35, 0x2c, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, 0x2c, 0x72, 0x69, 0x67, 0x68, - 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x3a, - 0x62, 0x39, 0x2c, 0x78, 0x3a, 0x62, 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, - 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, - 0x53, 0x2c, 0x0d, 0x0a, 0x30, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x35, 0x65, 0x30, 0x34, 0x30, 0x30, 0x30, 0x30, 0x31, 0x33, 0x30, 0x62, - 0x30, 0x30, 0x30, 0x30, 0x66, 0x66, 0x38, 0x37, 0x30, 0x30, 0x30, 0x31, - 0x2c, 0x58, 0x62, 0x6f, 0x78, 0x20, 0x53, 0x65, 0x72, 0x69, 0x65, 0x73, - 0x20, 0x58, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, - 0x72, 0x2c, 0x61, 0x3a, 0x62, 0x30, 0x2c, 0x62, 0x3a, 0x62, 0x31, 0x2c, - 0x62, 0x61, 0x63, 0x6b, 0x3a, 0x62, 0x38, 0x2c, 0x64, 0x70, 0x64, 0x6f, - 0x77, 0x6e, 0x3a, 0x68, 0x30, 0x2e, 0x34, 0x2c, 0x64, 0x70, 0x6c, 0x65, - 0x66, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x38, 0x2c, 0x64, 0x70, 0x72, 0x69, - 0x67, 0x68, 0x74, 0x3a, 0x68, 0x30, 0x2e, 0x32, 0x2c, 0x64, 0x70, 0x75, - 0x70, 0x3a, 0x68, 0x30, 0x2e, 0x31, 0x2c, 0x67, 0x75, 0x69, 0x64, 0x65, - 0x3a, 0x62, 0x39, 0x2c, 0x6c, 0x65, 0x66, 0x74, 0x73, 0x68, 0x6f, 0x75, - 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x34, 0x2c, 0x6c, 0x65, 0x66, 0x74, - 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x36, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, 0x61, 0x32, 0x2c, - 0x6c, 0x65, 0x66, 0x74, 0x78, 0x3a, 0x61, 0x30, 0x2c, 0x6c, 0x65, 0x66, - 0x74, 0x79, 0x3a, 0x61, 0x31, 0x2c, 0x6d, 0x69, 0x73, 0x63, 0x31, 0x3a, - 0x62, 0x31, 0x31, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x73, 0x68, 0x6f, - 0x75, 0x6c, 0x64, 0x65, 0x72, 0x3a, 0x62, 0x35, 0x2c, 0x72, 0x69, 0x67, - 0x68, 0x74, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x3a, 0x62, 0x37, 0x2c, 0x72, - 0x69, 0x67, 0x68, 0x74, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x3a, - 0x61, 0x35, 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x78, 0x3a, 0x61, 0x33, - 0x2c, 0x72, 0x69, 0x67, 0x68, 0x74, 0x79, 0x3a, 0x61, 0x34, 0x2c, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x3a, 0x62, 0x31, 0x30, 0x2c, 0x78, 0x3a, 0x62, - 0x32, 0x2c, 0x79, 0x3a, 0x62, 0x33, 0x2c, 0x70, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x3a, 0x69, 0x4f, 0x53, 0x2c, 0x0d, 0x0a -}; -#define SKA_GAMEPAD_DB_STR (const char*)SKA_GAMEPAD_DB_HEX -const unsigned int SKA_GAMEPAD_DB_SIZE = 503770; diff --git a/old_seika/input/sdl_input.h b/old_seika/input/sdl_input.h deleted file mode 100644 index 7001e6a..0000000 --- a/old_seika/input/sdl_input.h +++ /dev/null @@ -1,333 +0,0 @@ -#pragma once - -#include - -#include "input.h" -#include "sdl_gamepad_db.h" - -typedef struct SkaSDLGamepadData { - SDL_Gamepad* gamepad; - SkaInputDeviceIndex deviceIndex; -} SkaSDLGamepadData; - -typedef struct SkaSDLInputEvent { - SkaInputSourceType sourceType; - SkaInputTriggerType triggerType; - SkaInputDeviceIndex deviceIndex; - SkaInputKey key; - f32 axisMotionValue; -} SkaSDLInputEvent; - -static SkaSDLGamepadData gamepadData[SKA_INPUT_MAX_DEVICES]; -static SkaSDLGamepadData gamepadDataByPlayerIndex[SKA_INPUT_MAX_DEVICES]; -static uint32 activeGamepads = 0; - -SkaInputKey ska_sdl_keycode_to_input_key(SDL_GamepadButton keycode) { - switch ((int32)keycode) { - case SDLK_TAB: return SkaInputKey_KEYBOARD_TAB; - case SDLK_LEFT: return SkaInputKey_KEYBOARD_LEFT; - case SDLK_RIGHT: return SkaInputKey_KEYBOARD_RIGHT; - case SDLK_UP: return SkaInputKey_KEYBOARD_UP; - case SDLK_DOWN: return SkaInputKey_KEYBOARD_DOWN; - case SDLK_PAGEDOWN: return SkaInputKey_KEYBOARD_PAGE_DOWN; - case SDLK_PAGEUP: return SkaInputKey_KEYBOARD_PAGE_UP; - case SDLK_HOME: return SkaInputKey_KEYBOARD_HOME; - case SDLK_END: return SkaInputKey_KEYBOARD_END; - case SDLK_INSERT: return SkaInputKey_KEYBOARD_INSERT; - case SDLK_DELETE: return SkaInputKey_KEYBOARD_DELETE; - case SDLK_BACKSPACE: return SkaInputKey_KEYBOARD_BACKSPACE; - case SDLK_SPACE: return SkaInputKey_KEYBOARD_SPACE; - case SDLK_RETURN: return SkaInputKey_KEYBOARD_RETURN; - case SDLK_ESCAPE: return SkaInputKey_KEYBOARD_ESCAPE; - case SDLK_QUOTE: return SkaInputKey_KEYBOARD_QUOTE; - case SDLK_COMMA: return SkaInputKey_KEYBOARD_COMMA; - case SDLK_MINUS: return SkaInputKey_KEYBOARD_MINUS; - case SDLK_PERIOD: return SkaInputKey_KEYBOARD_PERIOD; - case SDLK_SLASH: return SkaInputKey_KEYBOARD_SLASH; - case SDLK_SEMICOLON: return SkaInputKey_KEYBOARD_SEMICOLON; - case SDLK_EQUALS: return SkaInputKey_KEYBOARD_EQUALS; - case SDLK_LEFTBRACKET: return SkaInputKey_KEYBOARD_LEFT_BRACKET; - case SDLK_BACKSLASH: return SkaInputKey_KEYBOARD_BACKSLASH; - case SDLK_RIGHTBRACKET: return SkaInputKey_KEYBOARD_RIGHT_BRACKET; - case SDLK_BACKQUOTE: return SkaInputKey_KEYBOARD_BACKQUOTE; - case SDLK_CAPSLOCK: return SkaInputKey_KEYBOARD_CAPS_LOCK; - case SDLK_SCROLLLOCK: return SkaInputKey_KEYBOARD_SCROLL_LOCK; - case SDLK_NUMLOCKCLEAR: return SkaInputKey_KEYBOARD_NUM_LOCK_CLEAR; - case SDLK_PRINTSCREEN: return SkaInputKey_KEYBOARD_PRINT_SCREEN; - case SDLK_PAUSE: return SkaInputKey_KEYBOARD_PAUSE; - case SDLK_KP_0: return SkaInputKey_KEYBOARD_KEYPAD_0; - case SDLK_KP_1: return SkaInputKey_KEYBOARD_KEYPAD_1; - case SDLK_KP_2: return SkaInputKey_KEYBOARD_KEYPAD_2; - case SDLK_KP_3: return SkaInputKey_KEYBOARD_KEYPAD_3; - case SDLK_KP_4: return SkaInputKey_KEYBOARD_KEYPAD_4; - case SDLK_KP_5: return SkaInputKey_KEYBOARD_KEYPAD_5; - case SDLK_KP_6: return SkaInputKey_KEYBOARD_KEYPAD_6; - case SDLK_KP_7: return SkaInputKey_KEYBOARD_KEYPAD_7; - case SDLK_KP_8: return SkaInputKey_KEYBOARD_KEYPAD_8; - case SDLK_KP_9: return SkaInputKey_KEYBOARD_KEYPAD_9; - case SDLK_KP_PERIOD: return SkaInputKey_KEYBOARD_KEYPAD_PERIOD; - case SDLK_KP_MULTIPLY: return SkaInputKey_KEYBOARD_KEYPAD_MULTIPLY; - case SDLK_KP_MINUS: return SkaInputKey_KEYBOARD_KEYPAD_MINUS; - case SDLK_KP_PLUS: return SkaInputKey_KEYBOARD_KEYPAD_PLUS; - case SDLK_KP_ENTER: return SkaInputKey_KEYBOARD_KEYPAD_ENTER; - case SDLK_KP_EQUALS: return SkaInputKey_KEYBOARD_KEYPAD_EQUALS; - case SDLK_LCTRL: return SkaInputKey_KEYBOARD_LEFT_CONTROL; - case SDLK_LSHIFT: return SkaInputKey_KEYBOARD_LEFT_SHIFT; - case SDLK_LALT: return SkaInputKey_KEYBOARD_LEFT_ALT; - case SDLK_LGUI: return SkaInputKey_KEYBOARD_LEFT_GUI; - case SDLK_RCTRL: return SkaInputKey_KEYBOARD_RIGHT_CONTROL; - case SDLK_RSHIFT: return SkaInputKey_KEYBOARD_RIGHT_SHIFT; - case SDLK_RALT: return SkaInputKey_KEYBOARD_RIGHT_ALT; - case SDLK_RGUI: return SkaInputKey_KEYBOARD_RIGHT_GUI; - case SDLK_APPLICATION: return SkaInputKey_KEYBOARD_APPLICATION; - case SDLK_0: return SkaInputKey_KEYBOARD_NUM_0; - case SDLK_1: return SkaInputKey_KEYBOARD_NUM_1; - case SDLK_2: return SkaInputKey_KEYBOARD_NUM_2; - case SDLK_3: return SkaInputKey_KEYBOARD_NUM_3; - case SDLK_4: return SkaInputKey_KEYBOARD_NUM_4; - case SDLK_5: return SkaInputKey_KEYBOARD_NUM_5; - case SDLK_6: return SkaInputKey_KEYBOARD_NUM_6; - case SDLK_7: return SkaInputKey_KEYBOARD_NUM_7; - case SDLK_8: return SkaInputKey_KEYBOARD_NUM_8; - case SDLK_9: return SkaInputKey_KEYBOARD_NUM_9; - case SDLK_a: return SkaInputKey_KEYBOARD_A; - case SDLK_b: return SkaInputKey_KEYBOARD_B; - case SDLK_c: return SkaInputKey_KEYBOARD_C; - case SDLK_d: return SkaInputKey_KEYBOARD_D; - case SDLK_e: return SkaInputKey_KEYBOARD_E; - case SDLK_f: return SkaInputKey_KEYBOARD_F; - case SDLK_g: return SkaInputKey_KEYBOARD_G; - case SDLK_h: return SkaInputKey_KEYBOARD_H; - case SDLK_i: return SkaInputKey_KEYBOARD_I; - case SDLK_j: return SkaInputKey_KEYBOARD_J; - case SDLK_k: return SkaInputKey_KEYBOARD_K; - case SDLK_l: return SkaInputKey_KEYBOARD_L; - case SDLK_m: return SkaInputKey_KEYBOARD_M; - case SDLK_n: return SkaInputKey_KEYBOARD_N; - case SDLK_o: return SkaInputKey_KEYBOARD_O; - case SDLK_p: return SkaInputKey_KEYBOARD_P; - case SDLK_q: return SkaInputKey_KEYBOARD_Q; - case SDLK_r: return SkaInputKey_KEYBOARD_R; - case SDLK_s: return SkaInputKey_KEYBOARD_S; - case SDLK_t: return SkaInputKey_KEYBOARD_T; - case SDLK_u: return SkaInputKey_KEYBOARD_U; - case SDLK_v: return SkaInputKey_KEYBOARD_V; - case SDLK_w: return SkaInputKey_KEYBOARD_W; - case SDLK_x: return SkaInputKey_KEYBOARD_X; - case SDLK_y: return SkaInputKey_KEYBOARD_Y; - case SDLK_z: return SkaInputKey_KEYBOARD_Z; - case SDLK_F1: return SkaInputKey_KEYBOARD_F1; - case SDLK_F2: return SkaInputKey_KEYBOARD_F2; - case SDLK_F3: return SkaInputKey_KEYBOARD_F3; - case SDLK_F4: return SkaInputKey_KEYBOARD_F4; - case SDLK_F5: return SkaInputKey_KEYBOARD_F5; - case SDLK_F6: return SkaInputKey_KEYBOARD_F6; - case SDLK_F7: return SkaInputKey_KEYBOARD_F7; - case SDLK_F8: return SkaInputKey_KEYBOARD_F8; - case SDLK_F9: return SkaInputKey_KEYBOARD_F9; - case SDLK_F10: return SkaInputKey_KEYBOARD_F10; - case SDLK_F11: return SkaInputKey_KEYBOARD_F11; - case SDLK_F12: return SkaInputKey_KEYBOARD_F12; - case SDLK_F13: return SkaInputKey_KEYBOARD_F13; - case SDLK_F14: return SkaInputKey_KEYBOARD_F14; - case SDLK_F15: return SkaInputKey_KEYBOARD_F15; - case SDLK_F16: return SkaInputKey_KEYBOARD_F16; - case SDLK_F17: return SkaInputKey_KEYBOARD_F17; - case SDLK_F18: return SkaInputKey_KEYBOARD_F18; - case SDLK_F19: return SkaInputKey_KEYBOARD_F19; - case SDLK_F20: return SkaInputKey_KEYBOARD_F20; - case SDLK_F21: return SkaInputKey_KEYBOARD_F21; - case SDLK_F22: return SkaInputKey_KEYBOARD_F22; - case SDLK_F23: return SkaInputKey_KEYBOARD_F23; - case SDLK_F24: return SkaInputKey_KEYBOARD_F24; - case SDLK_AC_BACK: return SkaInputKey_KEYBOARD_APP_BACK; - case SDLK_AC_FORWARD: return SkaInputKey_KEYBOARD_APP_FORWARD; - default: return SkaInputKey_INVALID; - } -} - - -SkaInputKey ska_sdl_mouse_button_to_input_key(SDL_MouseButtonEvent button) { - switch (button.button) { - case SDL_BUTTON_LEFT: return SkaInputKey_MOUSE_BUTTON_LEFT; - case SDL_BUTTON_RIGHT: return SkaInputKey_MOUSE_BUTTON_RIGHT; - case SDL_BUTTON_MIDDLE: return SkaInputKey_MOUSE_BUTTON_MIDDLE; - default: return SkaInputKey_INVALID; - } -} - -SkaInputKey ska_sdl_gamepad_button_to_input_key(SDL_GamepadButton button) { - switch (button) { - case SDL_GAMEPAD_BUTTON_SOUTH: return SkaInputKey_GAMEPAD_FACE_BUTTON_SOUTH; - case SDL_GAMEPAD_BUTTON_EAST: return SkaInputKey_GAMEPAD_FACE_BUTTON_EAST; - case SDL_GAMEPAD_BUTTON_WEST: return SkaInputKey_GAMEPAD_FACE_BUTTON_WEST; - case SDL_GAMEPAD_BUTTON_NORTH: return SkaInputKey_GAMEPAD_FACE_BUTTON_NORTH; - case SDL_GAMEPAD_BUTTON_BACK: return SkaInputKey_GAMEPAD_BACK; - case SDL_GAMEPAD_BUTTON_START: return SkaInputKey_GAMEPAD_START; - case SDL_GAMEPAD_BUTTON_LEFT_STICK: return SkaInputKey_GAMEPAD_LEFT_ANALOG_BUTTON; - case SDL_GAMEPAD_BUTTON_RIGHT_STICK: return SkaInputKey_GAMEPAD_RIGHT_ANALOG_BUTTON; - case SDL_GAMEPAD_BUTTON_LEFT_SHOULDER: return SkaInputKey_GAMEPAD_LEFT_SHOULDER; - case SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER: return SkaInputKey_GAMEPAD_RIGHT_SHOULDER; - case SDL_GAMEPAD_BUTTON_DPAD_UP: return SkaInputKey_GAMEPAD_DPAD_UP; - case SDL_GAMEPAD_BUTTON_DPAD_DOWN: return SkaInputKey_GAMEPAD_DPAD_DOWN; - case SDL_GAMEPAD_BUTTON_DPAD_LEFT: return SkaInputKey_GAMEPAD_DPAD_LEFT; - case SDL_GAMEPAD_BUTTON_DPAD_RIGHT: return SkaInputKey_GAMEPAD_DPAD_RIGHT; - default: return SkaInputKey_INVALID; - } -} - -SkaInputKey ska_sdl_gamepad_axis_to_input_key(SDL_GamepadAxis axis) { - switch (axis) { - case SDL_GAMEPAD_AXIS_LEFTX: return SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_X; - case SDL_GAMEPAD_AXIS_LEFTY: return SkaInputKey_GAMEPAD_LEFT_ANALOG_2D_AXIS_Y; - case SDL_GAMEPAD_AXIS_RIGHTX: return SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_X; - case SDL_GAMEPAD_AXIS_RIGHTY: return SkaInputKey_GAMEPAD_RIGHT_ANALOG_2D_AXIS_Y; - case SDL_GAMEPAD_AXIS_LEFT_TRIGGER: return SkaInputKey_GAMEPAD_LEFT_TRIGGER; - case SDL_GAMEPAD_AXIS_RIGHT_TRIGGER: return SkaInputKey_GAMEPAD_RIGHT_TRIGGER; - default: return SkaInputKey_INVALID; - } -} - -bool ska_sdl_load_gamepad_mappings() { - const int loadResult = SDL_AddGamepadMapping(SKA_GAMEPAD_DB_STR); - return loadResult >= 0; -} - -static inline void ska_sdl_notify_input_event(const SkaSDLInputEvent* inputEvent) { - ska_input_register_input_event(inputEvent->sourceType, inputEvent->key, inputEvent->triggerType, inputEvent->deviceIndex, inputEvent->axisMotionValue); -} - -void ska_sdl_process_event(SDL_Event event) { - SkaSDLInputEvent inputEvent = { - .sourceType = SkaInputSourceType_INVALID, - .triggerType = SkaInputTriggerType_INVALID, - .deviceIndex = SKA_INPUT_FIRST_PLAYER_DEVICE_INDEX, - .key = SkaInputKey_INVALID, - .axisMotionValue = 0.0f - }; - - switch (event.type) { - // Mouse - case SDL_EVENT_MOUSE_MOTION: { - SkaMouse* mouse = ska_input_get_mouse(); - mouse->position = (SkaVector2){ .x = (f32)event.motion.x, .y = (f32)event.motion.y }; - break; - } - - case SDL_EVENT_MOUSE_BUTTON_DOWN: - case SDL_EVENT_MOUSE_BUTTON_UP: { - inputEvent.sourceType = SkaInputSourceType_MOUSE; - inputEvent.triggerType = event.type == SDL_EVENT_MOUSE_BUTTON_DOWN ? SkaInputTriggerType_PRESSED : SkaInputTriggerType_RELEASED; - inputEvent.key = ska_sdl_mouse_button_to_input_key(event.button); - break; - } - // Keyboard - case SDL_EVENT_KEY_DOWN: - case SDL_EVENT_KEY_UP: { - inputEvent.sourceType = SkaInputSourceType_KEYBOARD; - inputEvent.triggerType = event.type == SDL_EVENT_KEY_DOWN ? SkaInputTriggerType_PRESSED : SkaInputTriggerType_RELEASED, - inputEvent.key = ska_sdl_keycode_to_input_key(event.key.keysym.sym); - break; - } - // Gamepad - case SDL_EVENT_GAMEPAD_ADDED: { - const SDL_JoystickID deviceIndex = event.gdevice.which; - SDL_Gamepad* newGamepad = SDL_OpenGamepad(deviceIndex); - const int playerIndex = SDL_GetGamepadPlayerIndex(newGamepad); - const SkaSDLGamepadData newGamepadData = { .gamepad = newGamepad, .deviceIndex = playerIndex }; - gamepadData[deviceIndex] = newGamepadData; - gamepadDataByPlayerIndex[playerIndex] = newGamepadData; - activeGamepads++; - - inputEvent.sourceType = SkaInputSourceType_GAMEPAD; - inputEvent.triggerType = SkaInputTriggerType_DEVICE_ADDED; - inputEvent.deviceIndex = playerIndex; - break; - } - case SDL_EVENT_GAMEPAD_REMOVED: { - const SDL_JoystickID deviceIndex = event.gdevice.which; - SDL_Gamepad* removedGamepad = gamepadData[deviceIndex].gamepad; - const SkaInputDeviceIndex playerIndex = gamepadData[deviceIndex].deviceIndex; - SDL_CloseGamepad(removedGamepad); - const SkaSDLGamepadData defaultGamepadData = (SkaSDLGamepadData){ .gamepad = NULL, .deviceIndex = -1 }; - gamepadData[deviceIndex] = defaultGamepadData; - gamepadDataByPlayerIndex[playerIndex] = defaultGamepadData; - activeGamepads--; - - inputEvent.sourceType = SkaInputSourceType_GAMEPAD; - inputEvent.triggerType = SkaInputTriggerType_DEVICE_REMOVED; - inputEvent.deviceIndex = playerIndex; - break; - } - case SDL_EVENT_GAMEPAD_BUTTON_DOWN: - case SDL_EVENT_GAMEPAD_BUTTON_UP: { - const SDL_JoystickID deviceIndex = event.jbutton.which; - const SkaInputDeviceIndex playerIndex = gamepadData[deviceIndex].deviceIndex; - const bool isButtonPressed = event.jbutton.state == SDL_PRESSED; - const SDL_GamepadButton buttonValue = event.jbutton.button; - - inputEvent.sourceType = SkaInputSourceType_GAMEPAD; - inputEvent.triggerType = isButtonPressed ? SkaInputTriggerType_PRESSED : SkaInputTriggerType_RELEASED; - inputEvent.deviceIndex = playerIndex; - inputEvent.key = ska_sdl_gamepad_button_to_input_key(buttonValue); - break; - } - default: - break; - } - ska_sdl_notify_input_event(&inputEvent); -} - -// Call after looping through all sdl input events for a frame -void ska_sdl_process_axis_events() { -#define SKA_SDL_GAMEPAD_AXIS_DEAD_ZONE 8000 -#define SKA_MAX_AXIS_VALUES 6 - - static const SDL_GamepadAxis AXIS_KEYS[SKA_MAX_AXIS_VALUES] = { - SDL_GAMEPAD_AXIS_LEFTX, SDL_GAMEPAD_AXIS_LEFTY, - SDL_GAMEPAD_AXIS_RIGHTX, SDL_GAMEPAD_AXIS_RIGHTY, - SDL_GAMEPAD_AXIS_LEFT_TRIGGER, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER - }; - static bool hasGamepadStoppedAxisMotion[SKA_INPUT_MAX_DEVICES][SKA_MAX_AXIS_VALUES] = { - {true, true, true, true, true, true}, - {true, true, true, true, true, true}, - {true, true, true, true, true, true}, - {true, true, true, true, true, true}, - {true, true, true, true, true, true}, - {true, true, true, true, true, true}, - {true, true, true, true, true, true}, - {true, true, true, true, true, true} - }; - - for (uint32 i = 0; i < activeGamepads; i++) { - SkaSDLGamepadData* currentGamepadData = &gamepadDataByPlayerIndex[i]; - for (SDL_GamepadAxis axis = 0; axis < SKA_MAX_AXIS_VALUES; axis++) { - const int16 axisValue = SDL_GetGamepadAxis(currentGamepadData->gamepad, axis); - const SkaInputTriggerType triggerType = - axisValue < SKA_SDL_GAMEPAD_AXIS_DEAD_ZONE && axisValue > -SKA_SDL_GAMEPAD_AXIS_DEAD_ZONE - ? SkaInputTriggerType_AXIS_STOPPED_MOTION : SkaInputTriggerType_AXIS_IN_MOTION; - // Skip sending event if axis motion is already stopped - bool *hasStoppedAxisMotion = &hasGamepadStoppedAxisMotion[i][axis]; - if (triggerType == SkaInputTriggerType_AXIS_STOPPED_MOTION) { - if (*hasStoppedAxisMotion) { - continue; - } else { - *hasStoppedAxisMotion = true; - } - } else { - *hasStoppedAxisMotion = false; - } - const f32 axisValueNormalized = ska_math_map_to_range((f32) axisValue, (f32) INT16_MIN, (f32) INT16_MAX,-1.0f, 1.0f); - const SkaSDLInputEvent inputEvent = { - .sourceType = SkaInputSourceType_GAMEPAD, - .triggerType = triggerType, - .deviceIndex = (SkaInputDeviceIndex)i, - .key = ska_sdl_gamepad_axis_to_input_key(axis), - .axisMotionValue = axisValueNormalized - }; - ska_sdl_notify_input_event(&inputEvent); - } - } - -#undef SKA_MAX_AXIS_VALUES -} diff --git a/old_seika/logger.c b/old_seika/logger.c deleted file mode 100644 index 6111a2d..0000000 --- a/old_seika/logger.c +++ /dev/null @@ -1,153 +0,0 @@ -#include "logger.h" - -#include -#include -#include - -#include "seika/string.h" -#include "memory.h" - -#define SKA_LOGGER_MAX_QUEUED_MESSAGES 16 - -static SkaLogLevel currentLogLevel = SkaLogLevel_ERROR; -static char* queuedLogMessages[SKA_LOGGER_MAX_QUEUED_MESSAGES]; -static usize queuedLogMessagesCount = 0; -static usize queuedLogMessagesIndex = 0; - -void ska_logger_set_level(SkaLogLevel level) { - currentLogLevel = level; -} - -void ska_logger_error(const char* fmt, ...) { - va_list args; - va_start(args, fmt); - if (currentLogLevel <= SkaLogLevel_ERROR) { - char str[SKA_LOG_BUFFER_SIZE]; - const char* logLevelText = "[ERROR] "; - ska_strcpy(str, logLevelText); - ska_strncat(str, fmt, (sizeof(str) - strlen(str) - 1) ); - ska_strncat(str, "\n", (sizeof(str) - strlen(str) - 1) ); - vfprintf(stderr, str, args); - } - va_end(args); -} - -void ska_logger_warn(const char* fmt, ...) { - va_list args; - va_start(args, fmt); - if (currentLogLevel <= SkaLogLevel_WARN) { - char str[SKA_LOG_BUFFER_SIZE]; - const char* logLevelText = "[WARN] "; - ska_strcpy(str, logLevelText); - ska_strncat(str, fmt, (sizeof(str) - strlen(str) - 1) ); - ska_strncat(str, "\n", (sizeof(str) - strlen(str) - 1) ); - vprintf(str, args); - } - va_end(args); -} - -void ska_logger_info(const char* fmt, ...) { - va_list args; - va_start(args, fmt); - if (currentLogLevel <= SkaLogLevel_INFO) { - char str[SKA_LOG_BUFFER_SIZE]; - const char* logLevelText = "[INFO] "; - ska_strcpy(str, logLevelText); - ska_strncat(str, fmt, (sizeof(str) - strlen(str) - 1) ); - ska_strncat(str, "\n", (sizeof(str) - strlen(str) - 1) ); - vprintf(str, args); - } - va_end(args); -} - -void ska_logger_debug(const char* fmt, ...) { - va_list args; - va_start(args, fmt); - if (currentLogLevel <= SkaLogLevel_DEBUG) { - char str[SKA_LOG_BUFFER_SIZE]; - const char* logLevelText = "[DEBUG] "; - ska_strcpy(str, logLevelText); - ska_strncat(str, fmt, (sizeof(str) - strlen(str) - 1) ); - ska_strncat(str, "\n", (sizeof(str) - strlen(str) - 1) ); - vprintf(str, args); - } - va_end(args); -} - -void ska_logger_message(const char* fmt, ...) { - va_list args; - va_start(args, fmt); - char str[SKA_LOG_BUFFER_SIZE]; - memset(str, 0, SKA_LOG_BUFFER_SIZE); - ska_strncat(str, fmt, (sizeof(str) - strlen(str) - 1) ); - ska_strncat(str, "\n", (sizeof(str) - strlen(str) - 1) ); - vfprintf(stdout, str, args); - va_end(args); -} - -void ska_logger_internal_queue_message(const char* fmt, ...) { - va_list args; - va_start(args, fmt); - if (currentLogLevel <= SkaLogLevel_WARN) { - char str[SKA_LOG_BUFFER_SIZE]; - const char* logLevelText = "[WARN] "; - ska_strcpy(str, logLevelText); - ska_strncat(str, fmt, (sizeof(str) - strlen(str) - 1) ); - ska_strncat(str, "\n", (sizeof(str) - strlen(str) - 1) ); - vsnprintf(str, sizeof(str), str, args); - - usize currentIndex; - if (queuedLogMessagesIndex + 1 >= SKA_LOGGER_MAX_QUEUED_MESSAGES) { - queuedLogMessagesIndex = 0; - currentIndex = 0; - } else { - currentIndex = queuedLogMessagesIndex++; - queuedLogMessagesCount++; - } - // Freeing in case we looped around - SKA_MEM_FREE(queuedLogMessages[currentIndex]); - queuedLogMessages[currentIndex] = ska_strdup(str); - } - va_end(args); -} - -bool ska_logger_internal_print_queue() { - if (queuedLogMessagesCount > 0) { - for (usize i = 0; i < queuedLogMessagesCount; i++) { - ska_logger_message(queuedLogMessages[i]); - SKA_MEM_FREE(queuedLogMessages[i]); - queuedLogMessages[i] = NULL; - } - queuedLogMessagesCount = 0; - queuedLogMessagesIndex = 0; - return true; - } - return false; -} - -const char* ska_logger_get_log_level_string(SkaLogLevel level) { - switch (level) { - case SkaLogLevel_DEBUG: - return "debug"; - case SkaLogLevel_INFO: - return "info"; - case SkaLogLevel_WARN: - return "warn"; - case SkaLogLevel_ERROR: - return "error"; - } - return NULL; -} - -SkaLogLevel ska_logger_get_log_level_enum(const char* level) { - if (strcmp(level, "debug") == 0) { - return SkaLogLevel_DEBUG; - } else if (strcmp(level, "info") == 0) { - return SkaLogLevel_INFO; - } else if (strcmp(level, "warn") == 0) { - return SkaLogLevel_WARN; - } else if (strcmp(level, "error") == 0) { - return SkaLogLevel_ERROR; - } - return SkaLogLevel_ERROR; -} diff --git a/old_seika/logger.h b/old_seika/logger.h deleted file mode 100644 index 32c9abd..0000000 --- a/old_seika/logger.h +++ /dev/null @@ -1,35 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#ifndef SKA_LOG_BUFFER_SIZE -#define SKA_LOG_BUFFER_SIZE 512 -#endif - -typedef enum SkaLogLevel { - SkaLogLevel_DEBUG = 0, - SkaLogLevel_INFO = 1, - SkaLogLevel_WARN = 2, - SkaLogLevel_ERROR = 3 -} SkaLogLevel; - -void ska_logger_set_level(SkaLogLevel level); -void ska_logger_error(const char* fmt, ...); -void ska_logger_warn(const char* fmt, ...); -void ska_logger_info(const char* fmt, ...); -void ska_logger_debug(const char* fmt, ...); -void ska_logger_message(const char* fmt, ...); - -void ska_logger_internal_queue_message(const char* fmt, ...); -bool ska_logger_internal_print_queue(); - -const char* ska_logger_get_log_level_string(SkaLogLevel level); -SkaLogLevel ska_logger_get_log_level_enum(const char* level); - -#ifdef __cplusplus -} -#endif diff --git a/old_seika/macro_utils.h b/old_seika/macro_utils.h deleted file mode 100644 index 6041873..0000000 --- a/old_seika/macro_utils.h +++ /dev/null @@ -1,4 +0,0 @@ -#pragma once - -#define SKA_MACRO_STRINGIFY(X) #X -#define SKA_MACRO_TO_STRING(X) SKA_MACRO_STRINGIFY(X) diff --git a/old_seika/math/curve_float.c b/old_seika/math/curve_float.c deleted file mode 100644 index d5197fb..0000000 --- a/old_seika/math/curve_float.c +++ /dev/null @@ -1,93 +0,0 @@ -#include "curve_float.h" - -#include "seika/math/math.h" -#include "seika/assert.h" - -// Helper functions -void control_point_swap(SkaCurveControlPoint* pointA, SkaCurveControlPoint* pointB) { - SkaCurveControlPoint temp = *pointA; - *pointA = *pointB; - *pointB = temp; -} - -// Function to perform Selection Sort -void selection_sort_curve_float(SkaCurveFloat* curve) { - usize minX; - // One by one move boundary of unsorted subarray - for (usize i = 0; i < curve->controlPointCount - 1; i++) { - // Find the minimum element in unsorted array - minX = i; - for (usize j = i + 1; j < curve->controlPointCount; j++) { - if (curve->controlPoints[j].x < curve->controlPoints[minX].x) { - minX = j; - } - } - // Swap the found minimum element - // with the first element - control_point_swap(&curve->controlPoints[minX], &curve->controlPoints[i]); - } -} - -//--- SkaCurveFloat ---// -void ska_curve_float_add_control_point(SkaCurveFloat* curve, SkaCurveControlPoint point) { - SKA_ASSERT_FMT(curve->controlPointCount + 1 < SKA_CURVE_MAX_CONTROL_POINTS, "Trying to add more points than max '%u'", SKA_CURVE_MAX_CONTROL_POINTS); - curve->controlPoints[curve->controlPointCount++] = point; - selection_sort_curve_float(curve); -} - -void ska_curve_float_add_control_points(SkaCurveFloat* curve, SkaCurveControlPoint points[], usize count) { - if (count == 0) { - return; - } - for (usize i = 0; i < count; i++) { - SKA_ASSERT_FMT(curve->controlPointCount + 1 < SKA_CURVE_MAX_CONTROL_POINTS, "Trying to add multiple points that go beyond the max of '%u'", SKA_CURVE_MAX_CONTROL_POINTS); - curve->controlPoints[curve->controlPointCount++] = points[i]; - } - selection_sort_curve_float(curve); -} - -bool ska_curve_float_remove_control_point(SkaCurveFloat* curve, f64 x, f64 y) { - for (usize i = 0; i < curve->controlPointCount; i++) { - SkaCurveControlPoint* point = &curve->controlPoints[i]; - if (ska_math_is_almost_equal_double_default(x, point->x) && ska_math_is_almost_equal_double_default(y, point->y)) { - // We've found a matching point so set it's x to the highest value, sort it, then decrement the point count. - point->x = DBL_MAX; - selection_sort_curve_float(curve); - curve->controlPointCount--; - return true; - } - } - return false; -} - -f64 ska_curve_float_eval(const SkaCurveFloat* curve, f64 t) { - if (curve->controlPointCount == 0) { - return 0.0; - } else if (curve->controlPointCount == 1) { - return curve->controlPoints[0].y; - } - usize leftIndex = 0; - usize rightIndex = curve->controlPointCount - 1; - while (rightIndex - leftIndex > 1) { - usize midIndex = (leftIndex + rightIndex) / 2; - if (t < curve->controlPoints[midIndex].x) { - rightIndex = midIndex; - } else { - leftIndex = midIndex; - } - } - - const SkaCurveControlPoint* leftPoint = &curve->controlPoints[leftIndex]; - const SkaCurveControlPoint* rightPoint = &curve->controlPoints[rightIndex]; - - const f64 t1 = (t - leftPoint->x) / (rightPoint->x - leftPoint->x); - const f64 t2 = t1 * t1; - const f64 t3 = t2 * t1; - - const f64 a = 2.0f * t3 - 3.0f * t2 + 1.0f; - const f64 b = -2.0f * t3 + 3.0f * t2; - const f64 c = t3 - 2.0f * t2 + t1; - const f64 d = t3 - t2; - - return a * leftPoint->y + b * rightPoint->y + c * leftPoint->tangentOut + d * rightPoint->tangentIn; -} diff --git a/old_seika/math/curve_float.h b/old_seika/math/curve_float.h deleted file mode 100644 index 16ed517..0000000 --- a/old_seika/math/curve_float.h +++ /dev/null @@ -1,33 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -#include -#include - -#include "seika/defines.h" - -#define SKA_CURVE_MAX_CONTROL_POINTS 16 - -typedef struct SkaCurveControlPoint { - f64 x; // a.k.a time - f64 y; // a.k.a value - f64 tangentIn; - f64 tangentOut; -} SkaCurveControlPoint; - -typedef struct SkaCurveFloat { - usize controlPointCount; - SkaCurveControlPoint controlPoints[SKA_CURVE_MAX_CONTROL_POINTS]; -} SkaCurveFloat; - -void ska_curve_float_add_control_point(SkaCurveFloat* curve, SkaCurveControlPoint point); -void ska_curve_float_add_control_points(SkaCurveFloat* curve, SkaCurveControlPoint points[], usize count); -bool ska_curve_float_remove_control_point(SkaCurveFloat* curve, f64 x, f64 y); -f64 ska_curve_float_eval(const SkaCurveFloat* curve, f64 t); - -#ifdef __cplusplus -} -#endif diff --git a/old_seika/math/math.c b/old_seika/math/math.c deleted file mode 100644 index 92f2923..0000000 --- a/old_seika/math/math.c +++ /dev/null @@ -1,176 +0,0 @@ -#include "math.h" - -// --- Vector2 --- // -bool ska_math_vec2_equals(const SkaVector2* v1, const SkaVector2* v2) { - return v1->x == v2->x && v1->y == v2->y; -} - -SkaVector2 ska_math_vec2_lerp(const SkaVector2* v1, const SkaVector2* v2, f32 alpha) { - return (SkaVector2) { - .x = ska_math_lerpf(v1->x, v2->x, alpha), - .y = ska_math_lerpf(v1->y, v2->y, alpha) - }; -} - -f32 ska_math_vec2_angle(const SkaVector2* v) { - f32 angle = atan2f(v->y, v->x); - if (angle < 0.0f) { - angle += 2.0f * SKA_PI; - } - return angle; -} - -// --- Rect2 --- // -bool se_rect2_does_rectangles_overlap(const SkaRect2* sourceRect, const SkaRect2* targetRect) { - return (sourceRect->x + sourceRect->w >= targetRect->x) && - (targetRect->x + targetRect->w >= sourceRect->x) && - (sourceRect->y + sourceRect->h >= targetRect->y) && - (targetRect->y + targetRect->h >= sourceRect->y); -} - -// --- Transform2D --- // -void ska_transform2d_mat4_to_transform(mat4 matrix, SkaTransform2D* transform) { - // Decompose trs matrix - vec4 translation; - mat4 rotation; - vec3 scale; - glm_decompose(matrix, translation, rotation, scale); - // Update position - transform->position = (SkaVector2){ .x = translation[0], .y = translation[1] }; - // Update scale - transform->scale = (SkaVector2){ .x = fabsf(scale[0]), .y = fabsf(scale[1]) }; - // Convert rotation to degrees - versor quat; - glm_mat4_quat(rotation, quat); - const f32 angleRadians = glm_quat_angle(quat); - transform->rotation = glm_deg(angleRadians); -} - -void ska_transform2d_transform_to_mat4(const SkaTransform2D* transform, mat4 matrix) { - // Create translation matrix - glm_translate_make(matrix, (vec3){transform->position.x, transform->position.y, 0.0f}); - // Create rotation matrix (convert degrees to radians) - glm_rotate_z(matrix, glm_rad(transform->rotation), matrix); - // Create scale matrix - glm_scale(matrix, (vec3){transform->scale.x, transform->scale.y, 1.0f}); -} - -SkaTransform2D ska_transform2d_lerp(const SkaTransform2D* tA, const SkaTransform2D* tB, f32 alpha) { - return (SkaTransform2D) { - .position = ska_math_vec2_lerp(&tA->position, &tB->position, alpha), - .scale = ska_math_vec2_lerp(&tA->scale, &tB->scale, alpha), - .rotation = ska_math_lerpf(tA->rotation, tB->rotation, alpha) - }; -} - -// --- Transform2D Model --- // -SkaTransform2D ska_transform2d_model_convert_to_transform(SkaTransformModel2D* transformModel2D) { - SkaTransform2D transform2D; - ska_transform2d_mat4_to_transform(transformModel2D->model, &transform2D); - // Update scale sign - transform2D.scale = (SkaVector2){ .x = transform2D.scale.x * transformModel2D->scaleSign.x, .y = transform2D.scale.y * transformModel2D->scaleSign.y }; - return transform2D; -} - -// --- Color --- // -SkaColor ska_color_get_normalized_color_default_alpha(uint32 r, uint32 g, uint32 b) { - SkaColor color = { - .r = (f32) r / 255.0f, - .g = (f32) g / 255.0f, - .b = (f32) b / 255.0f, - .a = 1.0f - }; - return color; -} - -SkaColor ska_color_get_normalized_color(uint32 r, uint32 g, uint32 b, uint32 a) { - SkaColor color = { - .r = (f32) r / 255.0f, - .g = (f32) g / 255.0f, - .b = (f32) b / 255.0f, - .a = (f32) a / 255.0f - }; - return color; -} - -SkaColor ska_color_get_normalized_color_from_color(const SkaColor* color) { - SkaColor newColor = { - .r = color->r / 255.0f, - .g = color->g / 255.0f, - .b = color->b / 255.0f, - .a = color->a / 255.0f - }; - return newColor; -} - -SkaVector2 ska_math_minmax_vec2_get_random_in_range(const SkaMinMaxVec2* minmax) { - const SkaVector2 randomVector = { - .x = minmax->min.x + (f32)rand() / RAND_MAX * (minmax->max.x - minmax->min.x), - .y = minmax->min.y + (f32)rand() / RAND_MAX * (minmax->max.y - minmax->min.y), - }; - return randomVector; -} - -// --- Misc --- // -f32 ska_math_lerpf(f32 a, f32 b, f32 alpha) { - return a + (b - a) * alpha; -} - -f32 ska_math_map_to_range(f32 input, f32 inputMin, f32 inputMax, f32 outputMin, f32 outputMax) { - return (((input - inputMin) / (inputMax - inputMin)) * (outputMax - outputMin) + outputMin); -} - -f32 ska_math_map_to_unit(f32 input, f32 inputMin, f32 inputMax) { - return ska_math_map_to_range(input, inputMin, inputMax, 0.0f, 1.0f); -} - -f64 ska_math_map_to_range_double(f64 input, f64 inputMin, f64 inputMax, f64 outputMin, f64 outputMax) { - return (((input - inputMin) / (inputMax - inputMin)) * (outputMax - outputMin) + outputMin); -} - -f64 ska_math_map_to_unit_double(f64 input, f64 inputMin, f64 inputMax) { - return ska_math_map_to_range_double(input, inputMin, inputMax, 0.0, 1.0); -} - -f32 ska_math_signf(f32 value) { - if (value > 0.0f) { - return 1.0f; - } else if(value < 0.0f) { - return -1.0f; - } - return 0.0f; -} - -SkaVector2 ska_math_signvec2(SkaVector2* value) { - SkaVector2 sign_vec = { - .x = ska_math_signf(value->x), - .y = ska_math_signf(value->y) - }; - return sign_vec; -} - -int ska_math_clamp_int(int value, int min, int max) { - return value < min ? min : (value > max ? max : value); -} - -f32 ska_math_clamp_float(f32 value, f32 min, f32 max) { - return value < min ? min : (value > max ? max : value); -} - -bool ska_math_is_almost_equal_float(f32 v1, f32 v2, f32 epsilon) { - return fabsf(v1 - v2) <= epsilon; -} - -bool ska_math_is_almost_equal_float_default(f32 v1, f32 v2) { - static const f64 epsilon = 0.001f; - return fabsf(v1 - v2) <= epsilon; -} - -bool ska_math_is_almost_equal_double(f64 v1, f64 v2, f64 epsilon) { - return fabs(v1 - v2) <= epsilon; -} - -bool ska_math_is_almost_equal_double_default(f64 v1, f64 v2) { - static const f64 epsilon = 0.001; - return fabs(v1 - v2) <= epsilon; -} diff --git a/old_seika/math/math.h b/old_seika/math/math.h deleted file mode 100644 index 837cd2e..0000000 --- a/old_seika/math/math.h +++ /dev/null @@ -1,180 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef _MSC_VER -#define CGLM_ALL_UNALIGNED -#endif - -#include - -#include "seika/defines.h" - -#define SKA_PI 3.14159265358979323846f -#define SKA_RAD_2_DEG(RADIANS) ((RADIANS) * (180.0 / (f64)SKA_PI)) -#define SKA_RAD_2_DEGF(RADIANS) ((RADIANS) * (180.0f / SKA_PI)) -#define SKA_DEG_2_RAD(DEGREES) ((DEGREES) * ((f64)SKA_PI / 180.0)) -#define SKA_DEG_2_RADF(DEGREES) ((DEGREES) * (SKA_PI / 180.0f)) - - -// --- SkaVector2 --- // -typedef struct SkaVector2 { - f32 x; - f32 y; -} SkaVector2; - -#define SKA_VECTOR2_ZERO SKA_STRUCT_LITERAL(SkaVector2){ 0.0f, 0.0f } -#define SKA_VECTOR2_ONE SKA_STRUCT_LITERAL(SkaVector2){ 1.0f, 1.0f } -#define SKA_VECTOR2_LEFT SKA_STRUCT_LITERAL(SkaVector2){ -1.0f, 0.0f } -#define SKA_VECTOR2_RIGHT SKA_STRUCT_LITERAL(SkaVector2){ 1.0f, 0.0f } -#define SKA_VECTOR2_UP SKA_STRUCT_LITERAL(SkaVector2){ 0.0f, -1.0f } -#define SKA_VECTOR2_DOWN SKA_STRUCT_LITERAL(SkaVector2){ 0.0f, 1.0f } - -bool ska_math_vec2_equals(const SkaVector2* v1, const SkaVector2* v2); -SkaVector2 ska_math_vec2_lerp(const SkaVector2* v1, const SkaVector2* v2, f32 alpha); -f32 ska_math_vec2_angle(const SkaVector2* v); - -// --- SkaVector2i --- // -typedef struct SkaVector2i { - int32 x; - int32 y; -} SkaVector2i; - -#define SKA_VECTOR2I_ZERO SKA_STRUCT_LITERAL(SkaVector2i){ 0, 0 } -#define SKA_VECTOR2I_ONE SKA_STRUCT_LITERAL(SkaVector2i){ 1, 1 } -#define SKA_VECTOR2I_LEFT SKA_STRUCT_LITERAL(SkaVector2i){ -1, 0 } -#define SKA_VECTOR2I_RIGHT SKA_STRUCT_LITERAL(SkaVector2i){ 1, 0 } -#define SKA_VECTOR2I_UP SKA_STRUCT_LITERAL(SkaVector2i){ 0, -1 } -#define SKA_VECTOR2I_DOWN SKA_STRUCT_LITERAL(SkaVector2i){ 0, 1 } - -// --- SkaSize2D --- // -typedef struct SkaSize2D { - f32 w; - f32 h; -} SkaSize2D; - -#define SKA_SIZE2D_ZERO SKA_STRUCT_LITERAL(SkaSize2D){ 0.0f, 0.0f } - -// --- SkaSize2Di --- // -typedef struct SkaSize2Di { - int32 w; - int32 h; -} SkaSize2Di; - -#define SKA_SIZE2DI_ZERO SKA_STRUCT_LITERAL(SkaSize2Di){ 0, 0 } - -// --- SkaRect2 --- // -typedef struct SkaRect2 { - f32 x; - f32 y; - f32 w; - f32 h; -} SkaRect2; - -#define SKA_RECT2D_ZERO SKA_STRUCT_LITERAL(SkaRect2){ 0.0f, 0.0f, 0.0f, 0.0f } - -bool se_rect2_does_rectangles_overlap(const SkaRect2* sourceRect, const SkaRect2* targetRect); - -//--- SkaTransform2D ---// -typedef struct SkaTransform2D { - SkaVector2 position; - SkaVector2 scale; - f32 rotation; // degrees -} SkaTransform2D; - -void ska_transform2d_mat4_to_transform(mat4 matrix, SkaTransform2D* transform); -void ska_transform2d_transform_to_mat4(const SkaTransform2D* transform, mat4 matrix); -SkaTransform2D ska_transform2d_lerp(const SkaTransform2D* tA, const SkaTransform2D* tB, f32 alpha); - -#define SKA_TRANSFORM_IDENTITY SKA_STRUCT_LITERAL(SkaTransform2D){ \ - .position = SKA_VECTOR2_ZERO, \ - .scale = SKA_VECTOR2_ONE, \ - .rotation = 0.0f \ -} - -typedef struct SkaTransformModel2D { - SkaVector2 position; - SkaVector2 scale; - f32 rotation; // degrees - int32 zIndex; - SkaVector2 scaleSign; - mat4 model; -} SkaTransformModel2D; - -SkaTransform2D ska_transform2d_model_convert_to_transform(SkaTransformModel2D* transformModel2D); - -#define SKA_TRANSFORM_MODEL_IDENTITY SKA_STRUCT_LITERAL(SkaTransformModel2D){ \ - .position = SKA_VECTOR2_ZERO, \ - .scale = SKA_VECTOR2_ONE, \ - .rotation = 0.0f, \ - .zIndex = 0, \ - .scaleSign = SKA_VECTOR2_ONE \ -} - -// --- SkaVector3 --- // -typedef struct SkaVector3 { - f32 x; - f32 y; - f32 z; -} SkaVector3; - -// --- SkaVector4 --- // -typedef struct SkaVector4 { - f32 x; - f32 y; - f32 z; - f32 w; -} SkaVector4; - -// --- SkaColor --- // -typedef struct SkaColor { - f32 r; - f32 g; - f32 b; - f32 a; -} SkaColor; - -#define SKA_COLOR_WHITE SKA_STRUCT_LITERAL(SkaColor){ 1.0f, 1.0f, 1.0f, 1.0f } -#define SKA_COLOR_BLACK SKA_STRUCT_LITERAL(SkaColor){ 0.0f, 0.0f, 0.0f, 1.0f } -#define SKA_COLOR_RED SKA_STRUCT_LITERAL(SkaColor){ 1.0f, 0.0f, 0.0f, 1.0f } -#define SKA_COLOR_GREEN SKA_STRUCT_LITERAL(SkaColor){ 0.0f, 1.0f, 0.0f, 1.0f } -#define SKA_COLOR_BLUE SKA_STRUCT_LITERAL(SkaColor){ 0.0f, 0.0f, 1.0f, 1.0f } - -SkaColor ska_color_get_normalized_color_default_alpha(uint32 r, uint32 g, uint32 b); -SkaColor ska_color_get_normalized_color(uint32 r, uint32 g, uint32 b, uint32 a); -SkaColor ska_color_get_normalized_color_from_color(const SkaColor* color); - -// --- SkaMinMaxVec2 --- // -typedef struct SkaMinMaxVec2 { - SkaVector2 min; - SkaVector2 max; -} SkaMinMaxVec2; - -#define SKA_MINMAX_VEC2_ZERO SKA_STRUCT_LITERAL(SkaMinMaxVec2){ SKA_VECTOR2_ZERO, SKA_VECTOR2_ZERO } - -SkaVector2 ska_math_minmax_vec2_get_random_in_range(const SkaMinMaxVec2* minmax); - -// --- Misc --- // -#define SKA_MATH_MIN(A, B) ((A) < (B) ? (A) : (B)) -#define SKA_MATH_MAX(A, B) ((A) > (B) ? (A) : (B)) -#define SKA_MATH_CLAMP(VAL, MIN_VAL, MAX_VAL) ((VAL) < (MIN_VAL) ? (MIN_VAL) : (VAL) > (MAX_VAL) ? (MAX_VAL) : (VAL)) - -f32 ska_math_lerpf(f32 a, f32 b, f32 alpha); -f32 ska_math_map_to_range(f32 input, f32 inputMin, f32 inputMax, f32 outputMin, f32 outputMax); -f32 ska_math_map_to_unit(f32 input, f32 inputMin, f32 inputMax); -f64 ska_math_map_to_range_double(f64 input, f64 inputMin, f64 inputMax, f64 outputMin, f64 outputMax); -f64 ska_math_map_to_unit_double(f64 input, f64 inputMin, f64 inputMax); -f32 ska_math_signf(f32 value); -SkaVector2 ska_math_signvec2(SkaVector2* value); -int32 ska_math_clamp_int(int32 value, int32 min, int32 max); -f32 ska_math_clamp_float(f32 value, f32 min, f32 max); -bool ska_math_is_almost_equal_float(f32 v1, f32 v2, f32 epsilon); -bool ska_math_is_almost_equal_float_default(f32 v1, f32 v2); -bool ska_math_is_almost_equal_double(f64 v1, f64 v2, f64 epsilon); -bool ska_math_is_almost_equal_double_default(f64 v1, f64 v2); - -#ifdef __cplusplus -} -#endif diff --git a/old_seika/memory.c b/old_seika/memory.c deleted file mode 100644 index e4e41ef..0000000 --- a/old_seika/memory.c +++ /dev/null @@ -1,25 +0,0 @@ -#include "seika/memory.h" -#include "seika/assert.h" - -void* ska_mem_allocate(usize size) { - void* memory = calloc(1, size); - SKA_ASSERT_FMT(memory, "Out of memory or allocate failed!, size = %d", size); - return memory; -} - -void* ska_mem_allocate_c(usize blocks, usize size) { - void* memory = calloc(blocks, size); - SKA_ASSERT_FMT(memory, "Out of memory or allocate_c failed!, size = %d", size); - return memory; -} - -void* ska_mem_reallocate(void* memory, usize size) { - void* reallocatedMemory = realloc(memory, size); - SKA_ASSERT_FMT(reallocatedMemory, "Out of memory or realloc failed!, size = %d", size); - return reallocatedMemory; -} - -void ska_mem_free(void* memory) { - free(memory); - memory = NULL; -} diff --git a/old_seika/memory.h b/old_seika/memory.h deleted file mode 100644 index 677ac41..0000000 --- a/old_seika/memory.h +++ /dev/null @@ -1,31 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -#include "defines.h" - -#define SKA_MEM_ALLOCATE(DataType) \ -(DataType*) ska_mem_allocate(sizeof(DataType)) - -#define SKA_MEM_ALLOCATE_ARRAY(DataType, ArraySize) \ -(DataType*) ska_mem_allocate_c(ArraySize, sizeof(DataType)) - -#define SKA_MEM_ALLOCATE_SIZE(Size) \ -ska_mem_allocate(Size) - -#define SKA_MEM_ALLOCATE_SIZE_ZERO(Blocks, Size) \ -ska_mem_allocate_c(Blocks, Size) - -#define SKA_MEM_FREE(Memory) \ -ska_mem_free(Memory) - -void* ska_mem_allocate(usize size); -void* ska_mem_allocate_c(usize blocks, usize size); -void* ska_mem_reallocate(void* memory, usize size); -void ska_mem_free(void* memory); - -#ifdef __cplusplus -} -#endif diff --git a/old_seika/networking/network.c b/old_seika/networking/network.c deleted file mode 100644 index 0d6a6ab..0000000 --- a/old_seika/networking/network.c +++ /dev/null @@ -1,143 +0,0 @@ -#include "network.h" - -#include -#include - -#include "network_socket.h" -#include "seika/logger.h" -#include "seika/assert.h" - -//--- NETWORK ---// -#define SKA_NETWORK_HANDSHAKE_MESSAGE "init" - -static bool ska_is_server = false; - -bool ska_network_is_server() { - return ska_is_server; -} - -//--- UDP SERVER ---// -#define SKA_SERVER_BUFFER_SIZE 512 - -static void* ska_udp_server_poll(void* arg); - -static ska_on_network_server_callback server_user_callback = NULL; -static ska_on_network_server_client_connected_callback server_client_connected_callback = NULL; - -static SkaSocket server_socket; - -bool ska_udp_server_initialize(int32 port, ska_on_network_server_callback user_callback) { - server_user_callback = user_callback; - ska_socket_system_initialize(); - server_socket = ska_socket_create_server(port, ska_udp_server_poll); - ska_is_server = true; - - return true; -} - -void ska_udp_server_register_client_connected_callback(ska_on_network_server_client_connected_callback client_connected_callback) { - server_client_connected_callback = client_connected_callback; -} - -void* ska_udp_server_poll(void* arg) { - static char server_input_buffer[SKA_SERVER_BUFFER_SIZE]; - //keep listening for data - while (true) { - fflush(stdout); - - //clear the buffer by filling null, it might have previously received data - memset(server_input_buffer, '\0', SKA_SERVER_BUFFER_SIZE); - //try to receive some data, this is a blocking call - if (!ska_socket_receive_data(&server_socket, server_input_buffer, SKA_SERVER_BUFFER_SIZE)) { - ska_logger_error("Failed to receive socket data with server!"); -// return NULL; - continue; - } - - // Process data from client - if (strcmp(server_input_buffer, SKA_NETWORK_HANDSHAKE_MESSAGE) == 0) { - if (server_client_connected_callback != NULL) { - server_client_connected_callback(); - } - ska_udp_server_send_message(SKA_NETWORK_HANDSHAKE_MESSAGE); - } else { - // Call user callback - server_user_callback(server_input_buffer); - } - } - return NULL; -} - -bool ska_udp_server_send_message(const char* message) { - if (!ska_socket_send_message(&server_socket, message)) { - ska_logger_error("Failed to send message '%s'", message); - return false; - } - return true; -} - -void ska_udp_server_finalize() { - ska_socket_close(&server_socket); - ska_socket_system_finalize(); -} - -//--- UDP CLIENT ---// -#define SKA_CLIENT_BUFFER_SIZE 512 - -static void* ska_udp_client_poll(void*); - -static SkaSocket client_socket; -static ska_on_network_client_callback client_user_callback = NULL; - -bool ska_udp_client_initialize(const char* serverAddr, int32 serverPort, ska_on_network_client_callback user_callback) { - client_user_callback = user_callback; - ska_socket_system_initialize(); - client_socket = ska_socket_create_client(serverAddr, serverPort, ska_udp_client_poll); - ska_logger_debug("Client: Initialized thread."); - - return true; -} - -void* ska_udp_client_poll(void *unused) { - static char client_input_buffer[SKA_CLIENT_BUFFER_SIZE]; - // TODO: Do handshake - // TODO: Figure out why there is failure if no message is sent at first - ska_socket_send_message(&client_socket, SKA_NETWORK_HANDSHAKE_MESSAGE); - - while (true) { - fflush(stdout); - //clear the buffer by filling null, it might have previously received data - memset(client_input_buffer, '\0', SKA_CLIENT_BUFFER_SIZE); - //try to receive some data, this is a blocking call - if (!ska_socket_receive_data(&client_socket, client_input_buffer, SKA_CLIENT_BUFFER_SIZE)) { - ska_logger_error("Failed to receive socket data from client!"); -// RBE_ASSERT(false); - continue; - } - - if (strcmp(client_input_buffer, SKA_NETWORK_HANDSHAKE_MESSAGE) == 0) { - if (server_client_connected_callback != NULL) { - server_client_connected_callback(); - } - } else { - // Call user callback - client_user_callback(client_input_buffer); - } - } - - return NULL; -} - -bool ska_udp_client_send_message(const char* message) { - if (!ska_socket_send_message(&client_socket, message)) { - ska_logger_error("Failed to send message '%s'", message); - return false; - } - - return true; -} - -void ska_udp_client_finalize() { - ska_socket_close(&client_socket); - ska_socket_system_finalize(); -} diff --git a/old_seika/networking/network.h b/old_seika/networking/network.h deleted file mode 100644 index dedf863..0000000 --- a/old_seika/networking/network.h +++ /dev/null @@ -1,24 +0,0 @@ -#pragma once - -#include - -#include "seika/defines.h" - -//--- NETWORK ---// -bool ska_network_is_server(); - -//--- UDP SERVER ---// -typedef void (*ska_on_network_server_callback) (const char*); -typedef void (*ska_on_network_server_client_connected_callback) (); - -bool ska_udp_server_initialize(int32 port, ska_on_network_server_callback user_callback); -void ska_udp_server_register_client_connected_callback(ska_on_network_server_client_connected_callback client_connected_callback); -bool ska_udp_server_send_message(const char* message); -void ska_udp_server_finalize(); - -//--- UDP CLIENT ---// -typedef void (*ska_on_network_client_callback) (const char*); - -bool ska_udp_client_initialize(const char* serverAddr, int32 serverPort, ska_on_network_client_callback user_callback); -bool ska_udp_client_send_message(const char* message); -void ska_udp_client_finalize(); diff --git a/old_seika/networking/network_socket.c b/old_seika/networking/network_socket.c deleted file mode 100644 index 6828cab..0000000 --- a/old_seika/networking/network_socket.c +++ /dev/null @@ -1,126 +0,0 @@ -#include "network_socket.h" - -#include - -#include "seika/logger.h" -#include "seika/assert.h" -#include "seika/string.h" -#include "seika/thread/pthread.h" - -//--- RBE Socket ---// -static int ska_socket_get_last_error() { -#ifdef _WIN32 - return WSAGetLastError(); -#else - return -1; -#endif -} - -bool ska_socket_system_initialize() { -#ifdef _WIN32 - // Initialise winsock - WSADATA wsa; - ska_logger_debug("Initialising client Winsock..."); - if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) { - ska_logger_error("Client: Failed. Error Code : %d", ska_socket_get_last_error()); - return false; - } - ska_logger_debug("Client: Initialized Winsock."); -#endif - return true; -} - -void ska_socket_system_finalize() { -#ifdef _WIN32 - WSACleanup(); -#endif -} - -bool ska_socket_send_message(SkaSocket* sock, const char* message) { -#define CRE_SOCKET_SEND_BUFFER_SIZE 512 - static char socket_output_buffer[CRE_SOCKET_SEND_BUFFER_SIZE]; - ska_strcpy(socket_output_buffer, message); - if (sendto(sock->sock, socket_output_buffer, (int) strlen(socket_output_buffer), 0, (struct sockaddr*) &sock->si_other, sock->size) == SOCKET_ERROR) { - ska_logger_error("sendto() failed with error code : %d", ska_socket_get_last_error()); - return false; - } - return true; -#undef CRE_SOCKET_SEND_BUFFER_SIZE -} - -bool ska_socket_receive_data(SkaSocket* sock, char* buffer, int32 buffer_size) { - if ((recvfrom(sock->sock, buffer, buffer_size, 0, (struct sockaddr*) &sock->si_other, &sock->size)) == SOCKET_ERROR) { - ska_logger_error("recvfrom() failed with error code : %d", ska_socket_get_last_error()); - return false; - } - return true; -} - -void ska_socket_close(SkaSocket* sock) {} - -//--- Server Socker ---// -static pthread_t server_thread; - -SkaSocket ska_socket_create_server(int32 port, ska_on_socket_receive_data callback_func) { - SKA_ASSERT_FMT(callback_func, "Callback func is NULL"); - SkaSocket sock; - sock.size = sizeof(sock.si_other); - - // Create a socket - if ((sock.sock = socket(AF_INET, SOCK_DGRAM, 0 )) == INVALID_SOCKET) { - SKA_ASSERT_FMT(false, "Server: could not create socket : %d", ska_socket_get_last_error()); - } - ska_logger_debug("Server: socket created!"); - - // Prepare the sockaddr_in structure - sock.si.sin_family = AF_INET; - sock.si.sin_addr.s_addr = INADDR_ANY; - sock.si.sin_port = htons(port); - - // Bind - if (bind(sock.sock, (struct sockaddr *) &sock.si, sizeof(sock.si)) == SOCKET_ERROR) { - SKA_ASSERT_FMT(false, "Server: Bind failed with error code : %d", ska_socket_get_last_error()); - } - ska_logger_debug("Server: Bind done!"); - - // Start Networking Thread - if (pthread_create(&server_thread, NULL, callback_func, NULL) != 0) { - SKA_ASSERT_FMT(false, "Failed to create server thread!"); - } - ska_logger_debug("Server: Initialized thread."); - return sock; -} - -//--- Client Socket ---// -static pthread_t client_thread; - -SkaSocket ska_socket_create_client(const char* serverAddr, int32 serverPort, ska_on_socket_receive_data callback_func) { - //create socket - SkaSocket sock; - sock.size = sizeof(sock.si_other); - ska_logger_debug("Client: Creating socket...."); - if ((int) (sock.sock = (int) socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == SOCKET_ERROR) { - SKA_ASSERT_FMT(false, "Client: socket() failed with error code : %d", ska_socket_get_last_error()); - } - ska_logger_debug("Client: socket created."); - - // setup address structure - memset((char*) &sock.si_other, 0, sizeof(sock.si_other)); - sock.si_other.sin_family = AF_INET; - sock.si_other.sin_port = htons(serverPort); -#ifdef _WIN32 - sock.si_other.sin_addr.S_un.S_addr = inet_addr(serverAddr); -#else - if (inet_aton(serverAddr, &sock.si_other.sin_addr) == 0) { - SKA_ASSERT_FMT(false, "inet_aton() failed!"); - } -#endif - - // Start Networking Thread - if (pthread_create(&client_thread, NULL, callback_func, NULL) != 0) { - SKA_ASSERT_FMT(false, "Failed to create server thread!"); - } - - ska_logger_debug("Client: Initialized thread."); - return sock; -} diff --git a/old_seika/networking/network_socket.h b/old_seika/networking/network_socket.h deleted file mode 100644 index dcc2693..0000000 --- a/old_seika/networking/network_socket.h +++ /dev/null @@ -1,43 +0,0 @@ -#pragma once - -#include - -#include "seika/defines.h" - -#ifdef _WIN32 -#include - -typedef int32 se_socket_size; -typedef SOCKET ska_socket; -#else -#include -#include - -#define SOCKET_ERROR (-1) -#define INVALID_SOCKET (-1) - -typedef socklen_t se_socket_size; -typedef int ska_socket; -#endif - -//--- RBE Socket---// -typedef void* (*ska_on_socket_receive_data) (void*); - -typedef struct SkaSocket { - ska_socket sock; - se_socket_size size; - struct sockaddr_in si; - struct sockaddr_in si_other; -} SkaSocket; - -bool ska_socket_system_initialize(); -void ska_socket_system_finalize(); -bool ska_socket_send_message(SkaSocket* sock, const char* message); -bool ska_socket_receive_data(SkaSocket* sock, char* buffer, int32 buffer_size); -void ska_socket_close(SkaSocket* sock); - -//--- Server Socket ---// -SkaSocket ska_socket_create_server(int32 port, ska_on_socket_receive_data callback_func); - -//--- Client Socket ---// -SkaSocket ska_socket_create_client(const char* serverAddr, int32 serverPort, ska_on_socket_receive_data callback_func); diff --git a/old_seika/platform.c b/old_seika/platform.c deleted file mode 100644 index 9211d12..0000000 --- a/old_seika/platform.c +++ /dev/null @@ -1,21 +0,0 @@ -#include "platform.h" - -#if defined(_WIN32) || defined(_WIN64) -#include -#elif defined(__APPLE__) -#include -#include -#elif defined(__linux__) -#include -#endif - -bool se_platform_is_debugger_attached() { -#if defined(_WIN32) || defined(_WIN64) - return IsDebuggerPresent(); -#elif defined(__APPLE__) - return (ptrace(PT_DENY_ATTACH, 0, 0, 0) == -1); -#elif defined(__linux__) - return (ptrace(PTRACE_TRACEME, 0, 1, 0) == -1); -#endif - return false; -} diff --git a/old_seika/platform.h b/old_seika/platform.h deleted file mode 100644 index 24b0ac7..0000000 --- a/old_seika/platform.h +++ /dev/null @@ -1,25 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -#include "stdbool.h" - -#if defined(_WIN32) || defined(_WIN64) // Windows -#define SKA_TRIGGER_BREAKPOINT __debugbreak() -#elif defined(__APPLE__) // macOS -#include -#define SKA_TRIGGER_BREAKPOINT raise(SIGTRAP) -#elif defined(__linux__) // Linux -#include -#define SKA_TRIGGER_BREAKPOINT raise(SIGTRAP) -#else -#define SKA_TRIGGER_BREAKPOINT -#endif - -bool se_platform_is_debugger_attached(); - -#ifdef __cplusplus -} -#endif diff --git a/old_seika/profile_code.h b/old_seika/profile_code.h deleted file mode 100644 index dded8e2..0000000 --- a/old_seika/profile_code.h +++ /dev/null @@ -1,74 +0,0 @@ -#pragma once - -#include -#include - -#include "seika/defines.h" - -// Experimental file that isn't in use... - -#define SKA_PROFILE_CODE(CodeBlock) \ -do { \ -clock_t start_time, end_time; \ -f32 cpu_time_used; \ -start_time = clock(); \ -CodeBlock \ -end_time = clock(); \ -cpu_time_used = ((f32)(end_time - start_time)) / CLOCKS_PER_SEC; \ -printf("Time taken: %f seconds\n", cpu_time_used); \ -} while (0) - -/* - * // Example - * SKA_PROFILE_CODE( - * for (int i = 0; i < 1000000; i++) {} - * ); - */ - -#define SKA_PROFILE_CODE_WITH_VAR(CpuTimeVar, CodeBlock) \ -do { \ -clock_t start_time, end_time; \ -start_time = clock(); \ -CodeBlock \ -end_time = clock(); \ -(CpuTimeVar) = ((f32)(end_time - start_time)) / CLOCKS_PER_SEC; \ -} while (0) - -/* - * // Example: - * f32 cpu_time_taken; - * SKA_PROFILE_CODE_WITH_VAR( - * cpu_time_taken, - * for (int i = 0; i < 1000000; i++) {} - * ); - * printf("Time taken: %f seconds\n", cpu_time_taken); - */ - - -typedef struct SkaBenchmarkItem { - f32 startTime; - f32 endTime; - f32 elapsedTime; - bool isRunning; -} SkaBenchmarkItem; - -void se_benchmark_start(SkaBenchmarkItem* benchmarkItem) { - benchmarkItem->startTime = (f32)clock() / CLOCKS_PER_SEC; - benchmarkItem->endTime = 0.0f; - benchmarkItem->elapsedTime = 0.0f; - benchmarkItem->isRunning = true; -} - -f32 se_benchmark_stop(SkaBenchmarkItem* benchmarkItem) { - benchmarkItem->endTime = (f32)clock() / CLOCKS_PER_SEC; - benchmarkItem->elapsedTime = benchmarkItem->endTime - benchmarkItem->startTime; - return benchmarkItem->elapsedTime; -} - -/* -// USAGE EXAMPLE -SkaBenchmarkItem benchmarkItem; -se_benchmark_start(&benchmarkItem); -// DO STUFF ... -se_logger_debug("elapsedTime = %f", se_benchmark_stop(&benchmarkItem)); -*/ diff --git a/old_seika/rendering/font.c b/old_seika/rendering/font.c deleted file mode 100644 index bc95e04..0000000 --- a/old_seika/rendering/font.c +++ /dev/null @@ -1,132 +0,0 @@ -#include "font.h" - -#include -#include FT_FREETYPE_H - -#include "render_context.h" -#include "seika/logger.h" -#include "seika/memory.h" -#include "seika/asset/asset_file_loader.h" - -static bool ska_generate_new_font_face(const char* fileName, FT_Face* face); -static void ska_initialize_font(FT_Face face, SkaFont* font, bool applyNearestNeighbor); - -SkaFont* ska_font_create_font(const char* fileName, int32 size, bool applyNearestNeighbor) { - FT_Face face; - SkaFont* font = SKA_MEM_ALLOCATE(SkaFont); - font->size = size; - - // Failed to create font, exit out early - if (!ska_generate_new_font_face(fileName, &face)) { - ska_logger_error("Freetype failed to load font '%s' with size '%d'!", fileName, size); - font->isValid = false; - FT_Done_Face(face); - return font; - } - - ska_initialize_font(face, font, applyNearestNeighbor); - - return font; -} - -SkaFont* ska_font_create_font_from_memory(const void* buffer, usize bufferSize, int32 size, bool applyNearestNeighbor) { - FT_Face face; - SkaFont* font = SKA_MEM_ALLOCATE(SkaFont); - font->size = size; - - // Failed to create font, exit out early - if(FT_New_Memory_Face(ska_render_context_get()->freeTypeLibrary, (unsigned char*)buffer, (FT_Long)bufferSize, 0, &face)) { - ska_logger_error("Freetype failed to load font from memory!!"); - font->isValid = false; - FT_Done_Face(face); - return font; - } - - ska_initialize_font(face, font, applyNearestNeighbor); - - return font; -} - -void ska_font_delete(SkaFont* font) { - SKA_MEM_FREE(font); -} - -bool ska_generate_new_font_face(const char* fileName, FT_Face* face) { - if (ska_asset_file_loader_get_read_mode() == SkaAssetFileLoaderReadMode_ARCHIVE) { - SkaArchiveFileAsset fileAsset = ska_asset_file_loader_get_asset(fileName); - if (ska_asset_file_loader_is_asset_valid(&fileAsset)) { - if (FT_New_Memory_Face(ska_render_context_get()->freeTypeLibrary, (unsigned char*) fileAsset.buffer, (FT_Long) fileAsset.bufferSize, 0, face)) { - // Failed to create new face - return false; - } - } else { - // Failed to load asset from archive - return false; - } - } else if (ska_asset_file_loader_get_read_mode() == SkaAssetFileLoaderReadMode_DISK) { - if (FT_New_Face(ska_render_context_get()->freeTypeLibrary, fileName, 0, face)) { - // Failed to create new face - return false; - } - } - return true; -} - -static void ska_initialize_font(FT_Face face, SkaFont* font, bool applyNearestNeighbor) { - // Set size to load glyphs, width set to 0 to dynamically adjust - FT_Set_Pixel_Sizes(face, 0, font->size); - // Disable byte alignment restriction - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); - // Load first 128 characters of ASCII set - for (unsigned char c = 0; c < 128; c++) { // 'c++' ;-) - // Load character glyph - if (FT_Load_Char(face, c, FT_LOAD_RENDER)) { - ska_logger_error("Freetype failed to load glyph '%u!", c); - continue; - } - // Generate texture - GLuint textTexture; - glGenTextures(1, &textTexture); - glBindTexture(GL_TEXTURE_2D, textTexture); - glTexImage2D( - GL_TEXTURE_2D, - 0, - GL_RED, - (GLsizei) face->glyph->bitmap.width, - (GLsizei) face->glyph->bitmap.rows, - 0, - GL_RED, - GL_UNSIGNED_BYTE, - face->glyph->bitmap.buffer - ); - // Texture wrap and filter options - const GLint filterType = applyNearestNeighbor ? GL_NEAREST : GL_LINEAR; - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filterType); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filterType); - // Create character struct - SkaFontCharacter character = { - .textureId = textTexture, - .size = { (f32)face->glyph->bitmap.width, (f32)face->glyph->bitmap.rows }, - .bearing = { (f32)face->glyph->bitmap_left, (f32)face->glyph->bitmap_top }, - .advance = (GLuint) face->glyph->advance.x - }; - font->characters[c] = character; - } - glBindTexture(GL_TEXTURE_2D, 0); - - // configure VAO & VBO texture quads - glGenVertexArrays(1, &font->VAO); - glGenBuffers(1, &font->VBO); - glBindVertexArray(font->VAO); - glBindBuffer(GL_ARRAY_BUFFER, font->VBO); - glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 6 * 4, NULL, GL_DYNAMIC_DRAW); - glEnableVertexAttribArray(0); - glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), NULL); - glBindBuffer(GL_ARRAY_BUFFER, 0); - glBindVertexArray(0); - font->isValid = true; - - FT_Done_Face(face); -} diff --git a/old_seika/rendering/font.h b/old_seika/rendering/font.h deleted file mode 100644 index 05cf742..0000000 --- a/old_seika/rendering/font.h +++ /dev/null @@ -1,26 +0,0 @@ -#pragma once - -#include - -#include - -#include "seika/math/math.h" - -typedef struct SkaFontCharacter { - GLuint textureId; - SkaVector2 size; - SkaVector2 bearing; - uint32 advance; -} SkaFontCharacter; - -typedef struct SkaFont { - bool isValid; - GLuint VAO; - GLuint VBO; - int32 size; - SkaFontCharacter characters[128]; // First 128 of ASCII set -} SkaFont; - -SkaFont* ska_font_create_font(const char* fileName, int32 size, bool applyNearestNeighbor); -SkaFont* ska_font_create_font_from_memory(const void* buffer, usize bufferSize, int32 size, bool applyNearestNeighbor); -void ska_font_delete(SkaFont* font); diff --git a/old_seika/rendering/frame_buffer.c b/old_seika/rendering/frame_buffer.c deleted file mode 100644 index 7c3866c..0000000 --- a/old_seika/rendering/frame_buffer.c +++ /dev/null @@ -1,181 +0,0 @@ -#include "frame_buffer.h" - -#include "shader/shader.h" -#include "shader/shader_instance.h" -#include "shader/shader_source.h" -#include "seika/logger.h" -#include "seika/assert.h" - -GLuint frameBuffer = -1; -GLuint textureColorBuffer = -1; -GLuint rbo = -1; -bool hasBeenInitialized = false; - -static SkaShaderInstance defaultScreenShader; -static SkaShaderInstance* currentScreenShader = NULL; -static GLuint screenVAO = -1; -static GLuint screenVBO = -1; - -static int32 screenTextureWidth = 800; -static int32 screenTextureHeight = 600; -static int32 resolutionWidth = 800; -static int32 resolutionHeight = 600; -static SkaFrameBufferViewportData cachedViewportData = { .position = { .x = 0, .y = 0 }, .size = { .w = 800, .h = 600 } }; -static bool maintainAspectRatio = false; - -SkaFrameBufferViewportData ska_frame_buffer_generate_viewport_data(int32 windowWidth, int32 windowHeight) { - int32 framebufferWidth = windowWidth; - int32 framebufferHeight = windowHeight; - - const f32 game_aspect_ratio = (f32)resolutionWidth / (f32)resolutionHeight; - const f32 window_aspect_ratio = (f32)windowWidth / (f32)windowHeight; - - // Adjust the framebuffer width or height to match the window aspect ratio - if (maintainAspectRatio && game_aspect_ratio != window_aspect_ratio) { - framebufferHeight = (int32)((f32)windowWidth / game_aspect_ratio); - if (framebufferHeight > windowHeight) { - framebufferHeight = windowHeight; - framebufferWidth = (int32)((f32)windowHeight * game_aspect_ratio); - } - } - - // Calculate the viewport dimensions - const int32 viewportX = (windowWidth - framebufferWidth) / 2; - const int32 viewportY = (windowHeight - framebufferHeight) / 2; - const int32 viewportWidth = framebufferWidth; - const int32 viewportHeight = framebufferHeight; - - const SkaFrameBufferViewportData data = { - .position = { .x = viewportX, .y = viewportY }, - .size = { .w = viewportWidth, .h = viewportHeight } - }; - cachedViewportData = data; - return data; -} - -SkaFrameBufferViewportData* ska_frame_buffer_get_cached_viewport_data() { - return &cachedViewportData; -} - -bool recreate_frame_buffer_object() { - // Create Framebuffer - glGenFramebuffers(1, &frameBuffer); - glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer); - // Create color attachment - glGenTextures(1, &textureColorBuffer); - glBindTexture(GL_TEXTURE_2D, textureColorBuffer); - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, screenTextureWidth, screenTextureHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); - glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureColorBuffer, 0); - // Create renderbuffer object for depth and stencil attachment - glGenRenderbuffers(1, &rbo); - glBindRenderbuffer(GL_RENDERBUFFER, rbo); - glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, screenTextureWidth, screenTextureHeight); - glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo); - // Check if framebuffer is complete - const bool success = glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE; - if (!success) { - ska_logger_error("Framebuffer is not complete!"); - } - glBindFramebuffer(GL_FRAMEBUFFER, 0); - return success; -} - -bool ska_frame_buffer_initialize(int32 inWindowWidth, int32 inWindowHeight, int32 inResolutionWidth, int32 inResolutionHeight) { - screenTextureWidth = inWindowWidth; - screenTextureHeight = inWindowHeight; - resolutionWidth = inResolutionWidth; - resolutionHeight = inResolutionHeight; - // VAO & VBO - // Initialize render data - glGenVertexArrays(1, &screenVAO); - glGenBuffers(1, &screenVBO); - glBindVertexArray(screenVAO); - glBindBuffer(GL_ARRAY_BUFFER, screenVBO); - // Set buffer data - GLfloat vertices[] = { - // pos // tex coords - -1.0f, 1.0f, 0.0f, 1.0f, - -1.0f, -1.0f, 0.0f, 0.0f, - 1.0f, -1.0f, 1.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 - }; - glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); - // position attribute - glEnableVertexAttribArray(0); - glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*) NULL); - // texture coords attribute - glEnableVertexAttribArray(1); - glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)(2 * sizeof(GLfloat))); - - glBindBuffer(GL_ARRAY_BUFFER, 0); - glBindVertexArray(0); - - bool success = recreate_frame_buffer_object(); - - // compile shaders - SkaShader* screenShader = ska_shader_compile_new_shader(SKA_OPENGL_SHADER_SOURCE_VERTEX_SCREEN, - SKA_OPENGL_SHADER_SOURCE_FRAGMENT_SCREEN); - defaultScreenShader = (SkaShaderInstance) { - .shader = screenShader, .paramMap = ska_string_hash_map_create_default_capacity() - }; - ska_frame_buffer_set_screen_shader(&defaultScreenShader); - ska_frame_buffer_generate_viewport_data(inWindowWidth, inWindowHeight); - - hasBeenInitialized = true; - return success; -} - -void ska_frame_buffer_finalize() { - ska_string_hash_map_destroy(defaultScreenShader.paramMap); - defaultScreenShader.paramMap = NULL; - hasBeenInitialized = false; -} - -void ska_frame_buffer_bind() { - SKA_ASSERT(hasBeenInitialized); - glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer); -} - -void ska_frame_buffer_unbind() { - glBindFramebuffer(GL_FRAMEBUFFER, 0); -} - -uint32 ska_frame_buffer_get_color_buffer_texture() { - return textureColorBuffer; -} - -uint32 ska_frame_buffer_get_quad_vao() { - return screenVAO; -} - -void ska_frame_buffer_resize_texture(int32 newWidth, int32 newHeight) { - screenTextureWidth = newWidth; - screenTextureHeight = newHeight; - recreate_frame_buffer_object(); -} - -void ska_frame_buffer_set_maintain_aspect_ratio(bool shouldMaintainAspectRatio) { - maintainAspectRatio = shouldMaintainAspectRatio; -} - -SkaShaderInstance* ska_frame_buffer_get_screen_shader() { - return currentScreenShader; -} - -void ska_frame_buffer_set_screen_shader(struct SkaShaderInstance *shaderInstance) { - SKA_ASSERT_FMT(shaderInstance != NULL, "Trying to set screen shader to NULL!"); - currentScreenShader = shaderInstance; - ska_shader_use(currentScreenShader->shader); - ska_shader_set_int(currentScreenShader->shader, "TEXTURE", 0); -} - -void ska_frame_buffer_reset_to_default_screen_shader() { - currentScreenShader = &defaultScreenShader; -} diff --git a/old_seika/rendering/frame_buffer.h b/old_seika/rendering/frame_buffer.h deleted file mode 100644 index e4dde6b..0000000 --- a/old_seika/rendering/frame_buffer.h +++ /dev/null @@ -1,34 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#include "seika/math/math.h" - -bool ska_frame_buffer_initialize(int32 inWindowWidth, int32 inWindowHeight, int32 inResolutionWidth, int32 inResolutionHeight); -void ska_frame_buffer_finalize(); -void ska_frame_buffer_bind(); -void ska_frame_buffer_unbind(); -uint32 ska_frame_buffer_get_color_buffer_texture(); -uint32 ska_frame_buffer_get_quad_vao(); -void ska_frame_buffer_resize_texture(int32 newWidth, int32 newHeight); -void ska_frame_buffer_set_maintain_aspect_ratio(bool shouldMaintainAspectRatio); - -struct SkaShaderInstance* ska_frame_buffer_get_screen_shader(); -void ska_frame_buffer_set_screen_shader(struct SkaShaderInstance* shaderInstance); -void ska_frame_buffer_reset_to_default_screen_shader(); - -typedef struct SkaFrameBufferViewportData { - SkaVector2i position; - SkaSize2Di size; -} SkaFrameBufferViewportData; - -SkaFrameBufferViewportData ska_frame_buffer_generate_viewport_data(int32 windowWidth, int32 windowHeight); -SkaFrameBufferViewportData* ska_frame_buffer_get_cached_viewport_data(); - -#ifdef __cplusplus -} -#endif diff --git a/old_seika/rendering/render_context.c b/old_seika/rendering/render_context.c deleted file mode 100644 index f329c0c..0000000 --- a/old_seika/rendering/render_context.c +++ /dev/null @@ -1,23 +0,0 @@ -#include "render_context.h" - -#include - -#include "seika/memory.h" -#include "seika/assert.h" - -static SkaRenderContext* renderContext = NULL; - -void ska_render_context_initialize() { - SKA_ASSERT_FMT(renderContext == NULL, "Render context is already initialized!"); - renderContext = SKA_MEM_ALLOCATE(SkaRenderContext); -} - -void ska_render_context_finalize() { - SKA_ASSERT_FMT(renderContext != NULL, "Render context is not initialized!"); - SKA_MEM_FREE(renderContext); -} - -SkaRenderContext* ska_render_context_get() { - SKA_ASSERT_FMT(renderContext != NULL, "Render context is not initialized!"); - return renderContext; -} diff --git a/old_seika/rendering/render_context.h b/old_seika/rendering/render_context.h deleted file mode 100644 index d34eaea..0000000 --- a/old_seika/rendering/render_context.h +++ /dev/null @@ -1,16 +0,0 @@ -#pragma once - -#include -#include FT_FREETYPE_H - -#include "seika/defines.h" - -typedef struct SkaRenderContext { - FT_Library freeTypeLibrary; - int32 windowWidth; - int32 windowHeight; -} SkaRenderContext; - -void ska_render_context_initialize(); -void ska_render_context_finalize(); -SkaRenderContext* ska_render_context_get(); diff --git a/old_seika/rendering/renderer.c b/old_seika/rendering/renderer.c deleted file mode 100644 index 6fd1d7e..0000000 --- a/old_seika/rendering/renderer.c +++ /dev/null @@ -1,610 +0,0 @@ -#include "renderer.h" - -#include -#include - -#include "render_context.h" -#include "shader/shader.h" -#include "shader/shader_cache.h" -#include "shader/shader_source.h" -#include "seika/assert.h" -#include "seika/logger.h" -#include "seika/data_structures/static_array.h" - -#define SKA_RENDER_TO_FRAMEBUFFER -#define SKA_RENDER_LAYER_BATCH_ITEM_MAX 1024 -#define SKA_RENDER_LAYER_FONT_BATCH_ITEM_MAX 100 -#define SKA_RENDER_TEXTURE_LAYER_TEXTURE_MAX 64 - -#ifdef SKA_RENDER_TO_FRAMEBUFFER -#include "frame_buffer.h" -#endif - -typedef struct SkaTextureCoordinates { - GLfloat sMin; - GLfloat sMax; - GLfloat tMin; - GLfloat tMax; -} SkaTextureCoordinates; - -static SkaTextureCoordinates renderer_get_texture_coordinates(const SkaTexture* texture, const SkaRect2* drawSource, bool flipH, bool flipV); -static void renderer_set_shader_instance_params(SkaShaderInstance* shaderInstance); -static void renderer_print_opengl_errors(); - -static void sprite_renderer_initialize(); -static void sprite_renderer_finalize(); -static void sprite_renderer_update_resolution(); - -static void font_renderer_initialize(); -static void font_renderer_finalize(); -static void font_renderer_update_resolution(); -static void font_renderer_draw_text(const SkaFont* font, const char* text, f32 x, f32 y, f32 scale, const SkaColor* color); - -static GLuint spriteQuadVAO; -static GLuint spriteQuadVBO; - -static SkaShader* spriteShader = NULL; -static SkaShader* fontShader = NULL; - -// Global Shader Params -static f32 globalShaderParamTime = 0.0f; - -static f32 resolutionWidth = 800.0f; -static f32 resolutionHeight = 600.0f; -static mat4 spriteProjection = { - {1.0f, 0.0f, 0.0f, 0.0f}, - {0.0f, 1.0f, 0.0f, 0.0f}, - {0.0f, 0.0f, 1.0f, 0.0f}, - {0.0f, 0.0f, 0.0f, 1.0f} -}; - -// Sprite Batching -typedef struct SpriteBatchItem { - SkaTexture* texture; - SkaRect2 sourceRect; - SkaSize2D destSize; - SkaColor color; - bool flipH; - bool flipV; - SkaRendererTransform2D transform2D; - SkaShaderInstance* shaderInstance; -} SpriteBatchItem; - -typedef struct FontBatchItem { - SkaFont* font; - const char* text; - f32 x; - f32 y; - f32 scale; - SkaColor color; -} FontBatchItem; - -void renderer_batching_draw_sprites(SpriteBatchItem items[], usize spriteCount); - -// Render Layer - Arranges draw order by z index -typedef struct RenderTextureLayer { - SpriteBatchItem spriteBatchItems[SKA_RENDER_LAYER_BATCH_ITEM_MAX]; - usize spriteBatchItemCount; -} RenderTextureLayer; - -typedef struct RenderLayer { - RenderTextureLayer renderTextureLayers[SKA_RENDER_TEXTURE_LAYER_TEXTURE_MAX]; - FontBatchItem fontBatchItems[SKA_RENDER_LAYER_FONT_BATCH_ITEM_MAX]; - usize renderTextureLayerCount; - usize fontBatchItemCount; -} RenderLayer; - -SKA_STATIC_ARRAY_CREATE(RenderLayer, SKA_RENDERER_MAX_Z_INDEX, render_layer_items); -SKA_STATIC_ARRAY_CREATE(int32, SKA_RENDERER_MAX_Z_INDEX, active_render_layer_items_indices); - -// Renderer -void ska_renderer_initialize(int32 inWindowWidth, int32 inWindowHeight, int32 inResolutionWidth, int32 inResolutionHeight, bool maintainAspectRatio) { - resolutionWidth = (f32)inResolutionWidth; - resolutionHeight = (f32)inResolutionHeight; - glEnable(GL_CULL_FACE); - glEnable(GL_BLEND); - glDisable(GL_MULTISAMPLE); - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - ska_render_context_initialize(); - ska_renderer_update_window_size(inWindowWidth, inWindowHeight); - sprite_renderer_initialize(); - font_renderer_initialize(); - ska_shader_cache_initialize(); -#ifdef SKA_RENDER_TO_FRAMEBUFFER - // Initialize framebuffer - SKA_ASSERT_FMT(ska_frame_buffer_initialize(inWindowWidth, inWindowHeight, inResolutionWidth, inResolutionHeight), "Framebuffer didn't initialize!"); - ska_frame_buffer_set_maintain_aspect_ratio(maintainAspectRatio); -#endif - // Set initial data for render layer - for (usize i = 0; i < SKA_RENDERER_MAX_Z_INDEX; i++) { - render_layer_items[i].renderTextureLayerCount = 0; - render_layer_items[i].fontBatchItemCount = 0; - for (usize j = 0; j < SKA_RENDER_TEXTURE_LAYER_TEXTURE_MAX; j++) { - render_layer_items[i].renderTextureLayers[j].spriteBatchItemCount = 0; - } - } -} - -void ska_renderer_finalize() { - font_renderer_finalize(); - sprite_renderer_finalize(); - ska_render_context_finalize(); - ska_shader_cache_finalize(); -#ifdef SKA_RENDER_TO_FRAMEBUFFER - ska_frame_buffer_finalize(); -#endif -} - -void ska_renderer_update_window_size(int32 windowWidth, int32 windowHeight) { -#ifdef SKA_RENDER_TO_FRAMEBUFFER - const SkaFrameBufferViewportData data = ska_frame_buffer_generate_viewport_data(windowWidth, windowHeight); -#else - struct ViewportData { - SKAVector2i position; - SKASize2Di size; - }; - const struct ViewportData data = { .position = { .x = 0, .y = 0 }, .size = { .w = windowWidth, .h = windowHeight } }; -#endif - glViewport(data.position.x, data.position.y, data.size.w, data.size.h); - SkaRenderContext* renderContext = ska_render_context_get(); - renderContext->windowWidth = data.size.w; - renderContext->windowHeight = data.size.h; -#ifdef SKA_RENDER_TO_FRAMEBUFFER - ska_frame_buffer_resize_texture(data.size.w, data.size.h); -#endif -} - -static inline void update_active_render_layer_index(int32 zIndex) { - const usize sizeBefore = SKA_STATIC_ARRAY_SIZE(active_render_layer_items_indices); - SKA_STATIC_ARRAY_ADD_IF_UNIQUE(active_render_layer_items_indices, zIndex); - const usize sizeAfter = SKA_STATIC_ARRAY_SIZE(active_render_layer_items_indices); - if (sizeBefore != sizeAfter) { - SKA_STATIC_ARRAY_SORT_INT(active_render_layer_items_indices); - } -} - -static inline void ska_renderer_queue_sprite_draw_call(SpriteBatchItem* item, int32 zIndex) { - const int32 arrayZIndex = ska_math_clamp_int(zIndex + SKA_RENDERER_MAX_Z_INDEX / 2, 0, SKA_RENDERER_MAX_Z_INDEX - 1); - // Get texture layer index for render texture - usize textureLayerIndex = render_layer_items[arrayZIndex].renderTextureLayerCount; - for (usize i = 0; i < render_layer_items[arrayZIndex].renderTextureLayerCount; i++) { - if (item->texture == render_layer_items[arrayZIndex].renderTextureLayers[i].spriteBatchItems[0].texture && item->shaderInstance == render_layer_items[arrayZIndex].renderTextureLayers[i].spriteBatchItems[0].shaderInstance) { - textureLayerIndex = i; - break; - } - } - RenderTextureLayer* textureLayer = &render_layer_items[arrayZIndex].renderTextureLayers[textureLayerIndex]; - // Increment render texture layer count if first sprite - if (textureLayer->spriteBatchItemCount == 0) { - render_layer_items[arrayZIndex].renderTextureLayerCount++; - } - // Copy batch item into batch items array and increment item count - SKA_ASSERT_FMT(textureLayer->spriteBatchItemCount + 1 < SKA_RENDER_LAYER_BATCH_ITEM_MAX, "Exceeded SKA_RENDER_LAYER_BATCH_ITEM_MAX '%d'", SKA_RENDER_LAYER_BATCH_ITEM_MAX); - SpriteBatchItem* currentItem = &textureLayer->spriteBatchItems[textureLayer->spriteBatchItemCount++]; - memcpy(currentItem, item, sizeof(SpriteBatchItem)); - // Update active render layer indices - update_active_render_layer_index(arrayZIndex); -} - -void ska_renderer_queue_sprite_draw(SkaTexture* texture, SkaRect2 sourceRect, SkaSize2D destSize, SkaColor color, bool flipH, bool flipV, const SkaTransform2D* transform2D, int32 zIndex, SkaShaderInstance* shaderInstance) { - if (texture == NULL) { - ska_logger_error("NULL texture, not submitting draw call!"); - return; - } - SpriteBatchItem item = (SpriteBatchItem){ .texture = texture, .sourceRect = sourceRect, .destSize = destSize, .color = color, .flipH = flipH, .flipV = flipV, .transform2D = { .model = {{0}} }, .shaderInstance = shaderInstance }; - ska_transform2d_transform_to_mat4(transform2D, item.transform2D.model); - ska_renderer_queue_sprite_draw_call(&item, zIndex); -} - -void ska_renderer_queue_sprite_draw2(SkaTexture* texture, SkaRect2 sourceRect, SkaSize2D destSize, SkaColor color, bool flipH, bool flipV, mat4 trsMatrix, int32 zIndex, SkaShaderInstance* shaderInstance) { - if (texture == NULL) { - ska_logger_error("NULL texture, not submitting draw call!"); - return; - } - SpriteBatchItem item = (SpriteBatchItem){ .texture = texture, .sourceRect = sourceRect, .destSize = destSize, .color = color, .flipH = flipH, .flipV = flipV, .transform2D = { .model = {{0}} }, .shaderInstance = shaderInstance }; - glm_mat4_copy(trsMatrix, item.transform2D.model); - ska_renderer_queue_sprite_draw_call(&item, zIndex); -} - -void ska_renderer_queue_font_draw_call(SkaFont* font, const char* text, f32 x, f32 y, f32 scale, SkaColor color, int32 zIndex) { - if (font == NULL) { - ska_logger_error("NULL font, not submitting draw call!"); - return; - } - - FontBatchItem item = { .font = font, .text = text, .x = x, .y = y, .scale = scale, .color = color }; - const int32 arrayZIndex = ska_math_clamp_int(zIndex + SKA_RENDERER_MAX_Z_INDEX / 2, 0, SKA_RENDERER_MAX_Z_INDEX - 1); - // Update font batch item on render layer - render_layer_items[arrayZIndex].fontBatchItems[render_layer_items[arrayZIndex].fontBatchItemCount++] = item; - // Update active render layer indices - update_active_render_layer_index(arrayZIndex); -} - -static void ska_renderer_flush_batches() { - for (usize i = 0; i < active_render_layer_items_indices_count; i++) { - const usize layerIndex = active_render_layer_items_indices[i]; - // Sprite - for (usize renderTextureIndex = 0; renderTextureIndex < render_layer_items[layerIndex].renderTextureLayerCount; renderTextureIndex++) { - RenderTextureLayer* renderTextureLayer = &render_layer_items[layerIndex].renderTextureLayers[renderTextureIndex]; - renderer_batching_draw_sprites(renderTextureLayer->spriteBatchItems, renderTextureLayer->spriteBatchItemCount); - renderTextureLayer->spriteBatchItemCount = 0; - } - render_layer_items[layerIndex].renderTextureLayerCount = 0; - // Font - for (usize fontIndex = 0; fontIndex < render_layer_items[layerIndex].fontBatchItemCount; fontIndex++) { - font_renderer_draw_text( - render_layer_items[layerIndex].fontBatchItems[fontIndex].font, - render_layer_items[layerIndex].fontBatchItems[fontIndex].text, - render_layer_items[layerIndex].fontBatchItems[fontIndex].x, - render_layer_items[layerIndex].fontBatchItems[fontIndex].y, - render_layer_items[layerIndex].fontBatchItems[fontIndex].scale, - &render_layer_items[layerIndex].fontBatchItems[fontIndex].color - ); - } - render_layer_items[layerIndex].fontBatchItemCount = 0; - } - - SKA_STATIC_ARRAY_EMPTY(render_layer_items); - SKA_STATIC_ARRAY_EMPTY(active_render_layer_items_indices); -} - -void ska_renderer_process_and_flush_batches(const SkaColor* backgroundColor) { -#ifdef SKA_RENDER_TO_FRAMEBUFFER - ska_frame_buffer_bind(); -#endif - - // Clear framebuffer with background color - glClearColor(backgroundColor->r, backgroundColor->g, backgroundColor->b, backgroundColor->a); - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); - -#ifdef SKA_RENDER_TO_FRAMEBUFFER - SkaFrameBufferViewportData* viewportData = ska_frame_buffer_get_cached_viewport_data(); - glViewport(0, 0, viewportData->size.w, viewportData->size.h); -#endif - - ska_renderer_flush_batches(); - -#ifdef SKA_RENDER_TO_FRAMEBUFFER - ska_frame_buffer_unbind(); - - // Clear screen texture background - static const SkaColor screenBackgroundColor = {0.0f, 0.0f, 0.0f, 1.0f }; - glClearColor(screenBackgroundColor.r, screenBackgroundColor.g, screenBackgroundColor.b, screenBackgroundColor.a); - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); - // Draw screen texture from framebuffer - SkaShaderInstance* screenShaderInstance = ska_frame_buffer_get_screen_shader(); - ska_shader_use(screenShaderInstance->shader); - - // Apply shader instance params - renderer_set_shader_instance_params(screenShaderInstance); - - glBindVertexArray(ska_frame_buffer_get_quad_vao()); - glViewport(viewportData->position.x, viewportData->position.y, viewportData->size.w, viewportData->size.h); - - glBindTexture(GL_TEXTURE_2D, ska_frame_buffer_get_color_buffer_texture()); // use the color attachment texture as the texture of the quad plane - glDrawArrays(GL_TRIANGLES, 0, 6); -#endif -} - -#ifdef SKA_RENDER_TO_FRAMEBUFFER -void ska_renderer_process_and_flush_batches_just_framebuffer(const SkaColor *backgroundColor) { - ska_frame_buffer_bind(); - - // Clear framebuffer with background color - glClearColor(backgroundColor->r, backgroundColor->g, backgroundColor->b, backgroundColor->a); - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); - - ska_renderer_flush_batches(); - - ska_frame_buffer_unbind(); -} -#endif - -// --- Sprite Renderer --- // -#define VERTS_STRIDE 10 -void sprite_renderer_initialize() { - GLfloat vertices[] = { - //id (1) // positions (2) // texture coordinates (2) // color (4) // is pixel art (1) - 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, - 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, - 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, - - 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, - 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, - 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f - }; - - // Initialize render data - glGenVertexArrays(1, &spriteQuadVAO); - glGenBuffers(1, &spriteQuadVBO); - - glBindBuffer(GL_ARRAY_BUFFER, spriteQuadVBO); - glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_DYNAMIC_DRAW); - - glBindVertexArray(spriteQuadVAO); - // id attribute - glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, VERTS_STRIDE * sizeof(GLfloat), (void*) NULL); - glEnableVertexAttribArray(0); - // position attribute - glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, VERTS_STRIDE * sizeof(GLfloat), (GLvoid*)(sizeof(GLfloat))); - glEnableVertexAttribArray(1); - // texture coords attribute - glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, VERTS_STRIDE * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); - glEnableVertexAttribArray(2); - // color attribute - glVertexAttribPointer(3, 4, GL_FLOAT, GL_FALSE, VERTS_STRIDE * sizeof(GLfloat), (GLvoid*)(5 * sizeof(GLfloat))); - glEnableVertexAttribArray(3); - // is pixel art attribute - glVertexAttribPointer(4, 1, GL_FLOAT, GL_FALSE, VERTS_STRIDE * sizeof(GLfloat), (GLvoid*)(9 * sizeof(GLfloat))); - glEnableVertexAttribArray(4); - - glBindBuffer(GL_ARRAY_BUFFER, 0); - glBindVertexArray(0); - - // compile shaders - spriteShader = ska_shader_compile_new_shader(SKA_OPENGL_SHADER_SOURCE_VERTEX_SPRITE, - SKA_OPENGL_SHADER_SOURCE_FRAGMENT_SPRITE); - sprite_renderer_update_resolution(); - ska_renderer_set_sprite_shader_default_params(spriteShader); -} - -void sprite_renderer_finalize() {} - -void ska_renderer_set_sprite_shader_default_params(SkaShader* shader) { - ska_shader_use(shader); - ska_shader_set_int(shader, "TEXTURE", 0); - ska_shader_set_mat4_float(shader, "CRE_PROJECTION", &spriteProjection); -} - -void sprite_renderer_update_resolution() { - glm_mat4_identity(spriteProjection); - glm_ortho(0.0f, resolutionWidth, resolutionHeight, 0.0f, -1.0f, 1.0f, spriteProjection); -} - -void renderer_batching_draw_sprites(SpriteBatchItem items[], usize spriteCount) { -#define MAX_SPRITE_COUNT 2000 -#define NUMBER_OF_VERTICES 6 -#define VERTEX_BUFFER_SIZE (VERTS_STRIDE * NUMBER_OF_VERTICES * MAX_SPRITE_COUNT) - - if (spriteCount <= 0) { - return; - } - - SKA_ASSERT(spriteCount <= MAX_SPRITE_COUNT); - - glDepthMask(false); - - glBindVertexArray(spriteQuadVAO); - glBindBuffer(GL_ARRAY_BUFFER, spriteQuadVBO); - - SkaTexture* texture = items[0].texture; - - GLfloat verts[VERTEX_BUFFER_SIZE]; - for (usize i = 0; i < spriteCount; i++) { - if (items[i].shaderInstance != NULL) { - ska_shader_use(items[i].shaderInstance->shader); - renderer_set_shader_instance_params(items[i].shaderInstance); - } else { - ska_shader_use(spriteShader); - } - - glm_scale(items[i].transform2D.model, (vec3) { - items[i].destSize.w, items[i].destSize.h, 1.0f - }); - const f32 spriteId = (f32) i; - const f32 determinate = glm_mat4_det(items[i].transform2D.model); - const SkaTextureCoordinates textureCoords = renderer_get_texture_coordinates(texture, &items[i].sourceRect, items[i].flipH, items[i].flipV); - // concat CRE_MODELS[] string for uniform param - char modelsBuffer[24]; - sprintf(modelsBuffer, "CRE_MODELS[%zu]", i); - ska_shader_set_mat4_float(spriteShader, modelsBuffer, &items[i].transform2D.model); - - // Loop over vertices - for (int32 j = 0; j < NUMBER_OF_VERTICES; j++) { - bool isSMin; - bool isTMin; - if (determinate >= 0.0f) { - isSMin = j == 0 || j == 2 || j == 3; - isTMin = j == 1 || j == 2 || j == 5; - } else { - isSMin = j == 1 || j == 2 || j == 5; - isTMin = j == 0 || j == 2 || j == 3; - } - const int32 row = (j * VERTS_STRIDE) + ((int32) i * (VERTS_STRIDE * NUMBER_OF_VERTICES)); - verts[row + 0] = spriteId; - verts[row + 1] = isSMin ? 0.0f : 1.0f; - verts[row + 2] = isTMin ? 0.0f : 1.0f; - verts[row + 3] = isSMin ? textureCoords.sMin : textureCoords.sMax; - verts[row + 4] = isTMin ? textureCoords.tMin : textureCoords.tMax; - verts[row + 5] = items[i].color.r; - verts[row + 6] = items[i].color.g; - verts[row + 7] = items[i].color.b; - verts[row + 8] = items[i].color.a; - verts[row + 9] = (f32)texture->applyNearestNeighbor; - } - } - - glActiveTexture(GL_TEXTURE0); - glBindTexture(GL_TEXTURE_2D, texture->id); - - glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr) sizeof(verts), verts, GL_DYNAMIC_DRAW); - glDrawArrays(GL_TRIANGLES, 0, (GLsizei) (spriteCount * NUMBER_OF_VERTICES)); - - renderer_print_opengl_errors(); - - glBindVertexArray(0); - glDepthMask(true); - -#undef MAX_SPRITE_COUNT -#undef NUMBER_OF_VERTICES -#undef VERTEX_BUFFER_SIZE -} -#undef VERTS_STRIDE - -// --- Font Renderer --- // -void font_renderer_initialize() { - if (FT_Init_FreeType(&ska_render_context_get()->freeTypeLibrary)) { - ska_logger_error("Unable to initialize FreeType library!"); - } - fontShader = ska_shader_compile_new_shader(SKA_OPENGL_SHADER_SOURCE_VERTEX_FONT, - SKA_OPENGL_SHADER_SOURCE_FRAGMENT_FONT); - font_renderer_update_resolution(); -} - -void font_renderer_finalize() { - FT_Done_FreeType(ska_render_context_get()->freeTypeLibrary); -} - -void font_renderer_update_resolution() { - mat4 proj = { - {1.0f, 0.0f, 0.0f, 0.0f}, - {0.0f, 1.0f, 0.0f, 0.0f}, - {0.0f, 0.0f, 1.0f, 0.0f}, - {0.0f, 0.0f, 0.0f, 1.0f} - }; - glm_ortho(0.0f, resolutionWidth, -resolutionHeight, 0.0f, -1.0f, 1.0f, proj); - ska_shader_use(fontShader); - ska_shader_set_mat4_float(fontShader, "projection", &proj); -} - -void font_renderer_draw_text(const SkaFont* font, const char* text, f32 x, f32 y, f32 scale, const SkaColor* color) { - SkaVector2 currentScale = {scale, scale }; - ska_shader_use(fontShader); - ska_shader_set_vec4_float(fontShader, "textColor", color->r, color->g, color->b, color->a); - glActiveTexture(GL_TEXTURE0); - glBindVertexArray(font->VAO); - - // Iterate through all characters - char* c = (char*) &text[0]; - const usize textLength = strlen(text); - for (usize i = 0; i < textLength; i++) { - SkaFontCharacter ch = font->characters[(int32) *c]; - const f32 xPos = x + (ch.bearing.x * currentScale.x); - const f32 yPos = -y - (ch.size.y - ch.bearing.y) * currentScale.x; // Invert Y because orthographic projection is flipped - const f32 w = ch.size.x * currentScale.x; - const f32 h = ch.size.y * currentScale.y; - // Update VBO for each characters - GLfloat verts[6][4] = { - {xPos, yPos + h, 0.0f, 0.0f}, - {xPos, yPos, 0.0f, 1.0f}, - {xPos + w, yPos, 1.0f, 1.0f}, - - {xPos, yPos + h, 0.0f, 0.0f}, - {xPos + w, yPos, 1.0f, 1.0f}, - {xPos + w, yPos + h, 1.0f, 0.0f} - }; - // Render glyph texture over quad - glBindTexture(GL_TEXTURE_2D, ch.textureId); - // Update content of VBO memory - glBindBuffer(GL_ARRAY_BUFFER, font->VBO); - glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(verts), verts); - // Render - glDrawArrays(GL_TRIANGLES, 0, 6); - x += (f32) (ch.advance >> 6) * currentScale.x; // bitshift by 6 to get value in pixels (2^6 = 64 (divide amount of 1/64th pixels by 64 to get amount of pixels)) - ++c; - } - // Unbind - glBindBuffer(GL_ARRAY_BUFFER, 0); - glBindVertexArray(0); - glBindTexture(GL_TEXTURE_2D, 0); -} - -// --- Misc --- // -SkaTextureCoordinates renderer_get_texture_coordinates(const SkaTexture* texture, const SkaRect2* drawSource, bool flipH, bool flipV) { - GLfloat sMin = 0.0f; - GLfloat sMax = 1.0f; - GLfloat tMin = 0.0f; - GLfloat tMax = 1.0f; - // S - if (texture->width != (GLsizei)drawSource->w || texture->height != (GLsizei)drawSource->h) { - sMin = (drawSource->x + 0.5f) / (f32) texture->width; - sMax = (drawSource->x + drawSource->w - 0.5f) / (f32) texture->width; - tMin = (drawSource->y + 0.5f) / (f32) texture->height; - tMax = (drawSource->y + drawSource->h - 0.5f) / (f32) texture->height; - } - if (flipH) { - const GLfloat tempSMin = sMin; - sMin = sMax; - sMax = tempSMin; - } - if (flipV) { - const GLfloat tempTMin = tMin; - tMin = tMax; - tMax = tempTMin; - } - return (SkaTextureCoordinates) { - sMin, sMax, tMin, tMax - }; -} - -void renderer_set_shader_instance_params(SkaShaderInstance* shaderInstance) { - // Set global shader params first - ska_shader_set_float(shaderInstance->shader, "TIME", globalShaderParamTime); - - // Now set shader params specific to the shader instance - if (shaderInstance->paramsDirty && shaderInstance->paramMap->size > 0) { - SKA_STRING_HASH_MAP_FOR_EACH(shaderInstance->paramMap, iter) { - SkaStringHashMapNode* node = iter.pair; - SkaShaderParam* param = (SkaShaderParam*) node->value; - switch (param->type) { - case SkaShaderParamType_BOOL: { - ska_shader_set_bool(shaderInstance->shader, param->name, param->value.boolValue); - break; - } - case SkaShaderParamType_INT: { - ska_shader_set_int(shaderInstance->shader, param->name, param->value.intValue); - break; - } - case SkaShaderParamType_FLOAT: { - ska_shader_set_float(shaderInstance->shader, param->name, param->value.floatValue); - break; - } - case SkaShaderParamType_FLOAT2: { - ska_shader_set_vec2_float(shaderInstance->shader, param->name, param->value.float2Value.x,param->value.float2Value.y); - break; - } - case SkaShaderParamType_FLOAT3: { - ska_shader_set_vec3_float(shaderInstance->shader, param->name, param->value.float3Value.x,param->value.float3Value.y, param->value.float3Value.z); - break; - } - case SkaShaderParamType_FLOAT4: { - ska_shader_set_vec4_float(shaderInstance->shader, param->name, param->value.float4Value.x,param->value.float4Value.y, param->value.float4Value.z,param->value.float4Value.w); - break; - } - } - } - shaderInstance->paramsDirty = false; - } -} - -void renderer_print_opengl_errors() { - GLenum err; - while ((err = glGetError()) != GL_NO_ERROR) { - printf("err = %d\n", err); - switch (err) { - case GL_NO_ERROR: - printf("GL_NO_ERROR\n"); - break; - case GL_INVALID_ENUM: - printf("GL_INVALID_ENUM\n"); - break; - case GL_INVALID_VALUE: - printf("GL_INVALID_VALUE\n"); - break; - case GL_INVALID_OPERATION: - printf("GL_INVALID_OPERATION\n"); - break; - case GL_INVALID_FRAMEBUFFER_OPERATION: - printf("GL_INVALID_FRAMEBUFFER_OPERATION\n"); - break; - default: - printf("default\n"); - break; - } - } -} - -// Shader param stuff -void ska_renderer_set_global_shader_param_time(f32 timeValue) { - globalShaderParamTime = timeValue; -} diff --git a/old_seika/rendering/renderer.h b/old_seika/rendering/renderer.h deleted file mode 100644 index 86c6df0..0000000 --- a/old_seika/rendering/renderer.h +++ /dev/null @@ -1,35 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -#include "texture.h" -#include "font.h" -#include "shader/shader_instance.h" -#include "seika/math/math.h" - -#define SKA_RENDERER_MAX_Z_INDEX 200 - -typedef struct SkaRendererTransform2D { - mat4 model; -} SkaRendererTransform2D; - -void ska_renderer_initialize(int32 inWindowWidth, int32 inWindowHeight, int32 inResolutionWidth, int32 inResolutionHeight, bool maintainAspectRatio); -void ska_renderer_finalize(); -void ska_renderer_update_window_size(int32 windowWidth, int32 windowHeight); -void ska_renderer_set_sprite_shader_default_params(SkaShader* shader); -void ska_renderer_queue_sprite_draw(SkaTexture* texture, SkaRect2 sourceRect, SkaSize2D destSize, SkaColor color, bool flipH, bool flipV, const SkaTransform2D* transform2D, int32 zIndex, SkaShaderInstance* shaderInstance); -void ska_renderer_queue_sprite_draw2(SkaTexture* texture, SkaRect2 sourceRect, SkaSize2D destSize, SkaColor color, bool flipH, bool flipV, mat4 trsMatrix, int32 zIndex, SkaShaderInstance* shaderInstance); -void ska_renderer_queue_font_draw_call(SkaFont* font, const char* text, f32 x, f32 y, f32 scale, SkaColor color, int32 zIndex); -void ska_renderer_process_and_flush_batches(const SkaColor *backgroundColor); -void ska_renderer_process_and_flush_batches_just_framebuffer(const SkaColor *backgroundColor); - -// Shader params -void ska_renderer_set_global_shader_param_time(f32 timeValue); - -#ifdef __cplusplus -} -#endif diff --git a/old_seika/rendering/shader/shader.c b/old_seika/rendering/shader/shader.c deleted file mode 100644 index 0bffc55..0000000 --- a/old_seika/rendering/shader/shader.c +++ /dev/null @@ -1,89 +0,0 @@ -#include "shader.h" - -#include "seika/logger.h" -#include "seika/memory.h" - -static bool shader_check_compile_errors(uint32 shaderId, const char* type); - -SkaShader* ska_shader_compile_new_shader(const char* vertexSource, const char* fragmentSource) { - SkaShader* shader = SKA_MEM_ALLOCATE(SkaShader); - GLuint vertex, fragment; - // vertex - vertex = glCreateShader(GL_VERTEX_SHADER); - glShaderSource(vertex, 1, &vertexSource, NULL); - glCompileShader(vertex); - shader_check_compile_errors(vertex, SKA_SHADER_VERTEX_TYPE); - // fragment - fragment = glCreateShader(GL_FRAGMENT_SHADER); - glShaderSource(fragment, 1, &fragmentSource, NULL); - glCompileShader(fragment); - if (!shader_check_compile_errors(vertex, SKA_SHADER_FRAGMENT_TYPE)) { - return NULL; - } - // attack and link shaders - shader->id = glCreateProgram(); - glAttachShader(shader->id, vertex); - glAttachShader(shader->id, fragment); - glLinkProgram(shader->id); - if (!shader_check_compile_errors(shader->id, SKA_SHADER_PROGRAM_TYPE)) { - return NULL; - } - glDeleteShader(vertex); - glDeleteShader(fragment); - return shader; -} - -void ska_shader_destroy(SkaShader* shader) { - SKA_MEM_FREE(shader); -} - -bool shader_check_compile_errors(uint32 shaderId, const char* type) { - GLint success; - char infoLog[1024]; - if(type == SKA_SHADER_PROGRAM_TYPE) { - glGetProgramiv(shaderId, GL_LINK_STATUS, &success); - if(!success) { - glGetProgramInfoLog(shaderId, 1024, NULL, infoLog); - ska_logger_error("Shader type '%s' linking failed!\nInfoLog = %s", type, &infoLog); - } - } else { - glGetShaderiv(shaderId, GL_COMPILE_STATUS, &success); - if(!success) { - glGetShaderInfoLog(shaderId, 1024, NULL, infoLog); - ska_logger_error("Shader type '%s' compilation failed!InfoLog = \n%s", type, &infoLog); - } - } - return success; -} - -void ska_shader_use(SkaShader* shader) { - glUseProgram(shader->id); -} - -void ska_shader_set_bool(SkaShader* shader, const char* name, bool value) { - glUniform1i(glGetUniformLocation(shader->id, name), (int32)value); -} - -void ska_shader_set_int(SkaShader* shader, const char* name, int32 value) { - glUniform1i(glGetUniformLocation(shader->id, name), value); -} - -void ska_shader_set_float(SkaShader* shader, const char* name, f32 value) { - glUniform1f(glGetUniformLocation(shader->id, name), value); -} - -void ska_shader_set_vec2_float(SkaShader* shader, const char* name, f32 v1, f32 v2) { - glUniform2f(glGetUniformLocation(shader->id, name), v1, v2); -} - -void ska_shader_set_vec3_float(SkaShader* shader, const char* name, f32 v1, f32 v2, f32 v3) { - glUniform3f(glGetUniformLocation(shader->id, name), v1, v2, v3); -} - -void ska_shader_set_vec4_float(SkaShader* shader, const char* name, f32 v1, f32 v2, f32 v3, f32 v4) { - glUniform4f(glGetUniformLocation(shader->id, name), v1, v2, v3, v4); -} - -void ska_shader_set_mat4_float(SkaShader* shader, const char* name, mat4* value) { - glUniformMatrix4fv(glGetUniformLocation(shader->id, name), 1, GL_FALSE, (f32*)value); -} diff --git a/old_seika/rendering/shader/shader.h b/old_seika/rendering/shader/shader.h deleted file mode 100644 index 15305e6..0000000 --- a/old_seika/rendering/shader/shader.h +++ /dev/null @@ -1,26 +0,0 @@ -#pragma once - -#include - -#include - -#include "seika/math/math.h" - -static const char* SKA_SHADER_VERTEX_TYPE = "VERTEX"; -static const char* SKA_SHADER_FRAGMENT_TYPE = "FRAGMENT"; -static const char* SKA_SHADER_PROGRAM_TYPE = "PROGRAM"; - -typedef struct SkaShader { - GLuint id; -} SkaShader; - -SkaShader* ska_shader_compile_new_shader(const char* vertexSource, const char* fragmentSource); -void ska_shader_destroy(SkaShader* shader); -void ska_shader_use(SkaShader* shader); -void ska_shader_set_bool(SkaShader* shader, const char* name, bool value); -void ska_shader_set_int(SkaShader* shader, const char* name, int32 value); -void ska_shader_set_float(SkaShader* shader, const char* name, f32 value); -void ska_shader_set_vec2_float(SkaShader* shader, const char* name, f32 v1, f32 v2); -void ska_shader_set_vec3_float(SkaShader* shader, const char* name, f32 v1, f32 v2, f32 v3); -void ska_shader_set_vec4_float(SkaShader* shader, const char* name, f32 v1, f32 v2, f32 v3, f32 v4); -void ska_shader_set_mat4_float(SkaShader* shader, const char* name, mat4* value); diff --git a/old_seika/rendering/shader/shader_cache.c b/old_seika/rendering/shader/shader_cache.c deleted file mode 100644 index 7b95ff4..0000000 --- a/old_seika/rendering/shader/shader_cache.c +++ /dev/null @@ -1,117 +0,0 @@ -#include "shader_cache.h" - -#include - -#include "shader_file_parser.h" -#include "seika/memory.h" -#include "seika/assert.h" -#include "seika/asset/asset_file_loader.h" -#include "seika/data_structures/queue.h" -#include "seika/logger.h" - -// --- Parsed Shader Cache --- // -typedef struct SkaParsedShaderCacheItem { - SkaShaderFileParseResult parseResult; -} SkaParsedShaderCacheItem; - -SkaStringHashMap* parsedShaderCacheMap = NULL; - -// --- Shader Cache --- // -static SkaShaderInstance* instanceCache[SKA_SHADER_INSTANCE_MAX_INSTANCES]; -static SkaQueue* shaderInstanceIdQueue = NULL; - -void ska_shader_cache_initialize() { - SKA_ASSERT(shaderInstanceIdQueue == NULL); - SKA_ASSERT(parsedShaderCacheMap == NULL); - shaderInstanceIdQueue = ska_queue_create(SKA_SHADER_INSTANCE_MAX_INSTANCES, SKA_SHADER_INSTANCE_INVALID_ID); - for (uint32_t i = 0; i < SKA_SHADER_INSTANCE_MAX_INSTANCES; i++) { - ska_queue_enqueue(shaderInstanceIdQueue, i); - instanceCache[i] = NULL; - } - parsedShaderCacheMap = ska_string_hash_map_create_default_capacity(); -} - -void ska_shader_cache_finalize() { - SKA_ASSERT(shaderInstanceIdQueue != NULL); - SKA_ASSERT(parsedShaderCacheMap != NULL); - ska_queue_destroy(shaderInstanceIdQueue); - shaderInstanceIdQueue = NULL; - SKA_STRING_HASH_MAP_FOR_EACH(parsedShaderCacheMap, iter) { - SkaStringHashMapNode* node = iter.pair; - SkaParsedShaderCacheItem* cacheItem = (SkaParsedShaderCacheItem*)node->value; - ska_shader_file_parse_clear_parse_result(&cacheItem->parseResult); - } - ska_string_hash_map_destroy(parsedShaderCacheMap); - parsedShaderCacheMap = NULL; -} - -SkaShaderInstanceId ska_shader_cache_add_instance(SkaShaderInstance* instance) { - const SkaShaderInstanceId newId = ska_queue_dequeue(shaderInstanceIdQueue); - instanceCache[newId] = instance; - return newId; -} - -void ska_shader_cache_remove_instance(SkaShaderInstanceId instanceId) { - instanceCache[instanceId] = NULL; - ska_queue_enqueue(shaderInstanceIdQueue, instanceId); -} - -SkaShaderInstance* ska_shader_cache_get_instance(SkaShaderInstanceId instanceId) { - return instanceCache[instanceId]; -} - -SkaShaderInstance* ska_shader_cache_get_instance_checked(SkaShaderInstanceId instanceId) { - if (instanceId != SKA_SHADER_INSTANCE_INVALID_ID) { - return instanceCache[instanceId]; - } - return NULL; -} - -SkaShaderInstanceId ska_shader_cache_create_instance_and_add(const char* shaderPath) { - if (!ska_string_hash_map_has(parsedShaderCacheMap, shaderPath)) { - char* shaderSource = ska_asset_file_loader_read_file_contents_as_string_without_raw(shaderPath, NULL); - // Uncomment when needing to debug shaders -// se_logger_debug("shader source = \n%s", shaderSource); - if (shaderSource) { - SkaParsedShaderCacheItem newCacheItem; - newCacheItem.parseResult = ska_shader_file_parser_parse_shader(shaderSource); - const bool hasErrorMessage = strlen(newCacheItem.parseResult.errorMessage) > 0; - if (hasErrorMessage) { - ska_logger_error("Shader parse error = '%s'\n", newCacheItem.parseResult.errorMessage); - return SKA_SHADER_INSTANCE_INVALID_ID; - } - ska_string_hash_map_add(parsedShaderCacheMap, shaderPath, &newCacheItem, sizeof(SkaParsedShaderCacheItem)); - } else { - ska_logger_error("Failed to read shader source from '%s'", shaderPath); - return SKA_SHADER_INSTANCE_INVALID_ID; - } - } - - SkaParsedShaderCacheItem* cacheItem = (SkaParsedShaderCacheItem*)ska_string_hash_map_get(parsedShaderCacheMap, shaderPath); - SkaShader* newShader = ska_shader_compile_new_shader(cacheItem->parseResult.parseData.fullVertexSource, cacheItem->parseResult.parseData.fullFragmentSource); - if (newShader == NULL) { - ska_logger_error("Error compiling shader from path = '%s'\n", shaderPath); - return SKA_SHADER_INSTANCE_INVALID_ID; - } - SkaShaderInstance* shaderInstance = ska_shader_instance_create_from_shader(newShader); - for (usize i = 0; i < cacheItem->parseResult.parseData.uniformCount; i++) { - ska_shader_instance_param_create_from_copy(shaderInstance, &cacheItem->parseResult.parseData.uniforms[i]); - } - SkaShaderInstanceId newId = ska_shader_cache_add_instance(shaderInstance); - return newId; -} - -SkaShaderInstanceId ska_shader_cache_create_instance_and_add_from_raw(const char* vertexPath, const char* fragmentPath) { - char* vertexSource = ska_asset_file_loader_read_file_contents_as_string(vertexPath, NULL); - char* fragmentSource = ska_asset_file_loader_read_file_contents_as_string(fragmentPath, NULL); - const SkaShaderInstanceId newId = ska_shader_cache_create_instance_and_add_from_source(vertexSource, fragmentSource); - SKA_MEM_FREE(vertexSource); - SKA_MEM_FREE(fragmentSource); - return newId; -} - -SkaShaderInstanceId ska_shader_cache_create_instance_and_add_from_source(const char* vertexSource, const char* fragmentSource) { - SkaShaderInstance* instance = ska_shader_instance_create(vertexSource, fragmentSource); - const SkaShaderInstanceId newId = ska_shader_cache_add_instance(instance); - return newId; -} diff --git a/old_seika/rendering/shader/shader_cache.h b/old_seika/rendering/shader/shader_cache.h deleted file mode 100644 index 22e023c..0000000 --- a/old_seika/rendering/shader/shader_cache.h +++ /dev/null @@ -1,19 +0,0 @@ -#pragma once - -#include "shader_instance_minimal.h" -#include "shader_instance.h" - -// Holds references to all custom shaders - -void ska_shader_cache_initialize(); -void ska_shader_cache_finalize(); - -SkaShaderInstanceId ska_shader_cache_add_instance(SkaShaderInstance* instance); -void ska_shader_cache_remove_instance(SkaShaderInstanceId instanceId); -SkaShaderInstance* ska_shader_cache_get_instance(SkaShaderInstanceId instanceId); -SkaShaderInstance* ska_shader_cache_get_instance_checked(SkaShaderInstanceId instanceId); -// Expects .shader files which contain vertex and fragment implementations -SkaShaderInstanceId ska_shader_cache_create_instance_and_add(const char* shaderPath); -// Should be a modification to the base shaders found in 'shader_source.h' -SkaShaderInstanceId ska_shader_cache_create_instance_and_add_from_raw(const char* vertexPath, const char* fragmentPath); -SkaShaderInstanceId ska_shader_cache_create_instance_and_add_from_source(const char* vertexSource, const char* fragmentSource); diff --git a/old_seika/rendering/shader/shader_file_parser.c b/old_seika/rendering/shader/shader_file_parser.c deleted file mode 100644 index 679560b..0000000 --- a/old_seika/rendering/shader/shader_file_parser.c +++ /dev/null @@ -1,607 +0,0 @@ -#include "shader_file_parser.h" - -#include - -#include "shader_source.h" -#include "seika/string.h" -#include "seika/memory.h" - -#define SHADER_FILE_PARSER_ERROR_RETURN(RESULT, SOURCE, MESSAGE) \ -ska_strcpy((RESULT).errorMessage, (MESSAGE)); \ -SKA_MEM_FREE((SOURCE)); \ -return (RESULT); - -#define SHADER_FILE_PARSER_ERROR_FMT_RETURN(RESULT, SOURCE, FMT, ...) \ -sprintf((RESULT).errorMessage, (FMT), ##__VA_ARGS__); \ -SKA_MEM_FREE((SOURCE)); \ -return (RESULT); - -static char* shader_file_parse_data_get_full_uniforms_source(SkaShaderFileParseData* parseData) { - if (parseData->uniformCount == 0) { - return NULL; - } - char uniformsBuffer[1024]; - uniformsBuffer[0] = '\0'; - for (usize i = 0; i < parseData->uniformCount; i++) { - ska_strcat(uniformsBuffer, "uniform "); - switch (parseData->uniforms[i].type) { - case SkaShaderParamType_BOOL: { - ska_strcat(uniformsBuffer, "bool "); - break; - } - case SkaShaderParamType_INT: { - ska_strcat(uniformsBuffer, "int "); - break; - } - case SkaShaderParamType_FLOAT: { - ska_strcat(uniformsBuffer, "float "); - break; - } - case SkaShaderParamType_FLOAT2: { - ska_strcat(uniformsBuffer, "vec2 "); - break; - } - case SkaShaderParamType_FLOAT3: { - ska_strcat(uniformsBuffer, "vec3 "); - break; - } - case SkaShaderParamType_FLOAT4: { - ska_strcat(uniformsBuffer, "vec4 "); - break; - } - default: - break; - } - ska_strcat(uniformsBuffer, parseData->uniforms[i].name); - ska_strcat(uniformsBuffer, ";\n"); - } - return ska_strdup(uniformsBuffer); -} - -char* shader_file_parse_data_get_full_functions_source(SkaShaderFileParseData* parseData) { - if (parseData->functionCount == 0) { - return NULL; - } - char functionsBuffer[4096]; - functionsBuffer[0] = '\0'; - for (usize i = 0; i < parseData->functionCount; i++) { - ska_strcat(functionsBuffer, parseData->functions[i].fullFunctionSource); - ska_strcat(functionsBuffer, "\n"); - } - return ska_strdup(functionsBuffer); -} - -void shader_file_parse_data_delete_internal_memory(SkaShaderFileParseData* parseData) { - SKA_MEM_FREE(parseData->fullVertexSource); - SKA_MEM_FREE(parseData->fullFragmentSource); - for (usize i = 0; i < parseData->functionCount; i++) { - SKA_MEM_FREE(parseData->functions[i].name); - SKA_MEM_FREE(parseData->functions[i].fullFunctionSource); - } -} - -// Will parse the next token, returns true if there is more source to parse -bool shader_file_find_next_token(char** shaderSource, char* tokenOut, bool* semiColonFound) { - tokenOut[0] = '\0'; - - if (semiColonFound) { - *semiColonFound = false; - } - - int tokenIndex = 0; - while (*(*shaderSource) != '\0') { - if (*(*shaderSource) == ' ' || *(*shaderSource) == ';') { - if (semiColonFound && *(*shaderSource) == ';') { - *semiColonFound = true; - } - (*shaderSource)++; - tokenOut[tokenIndex] = '\0'; - return true; - } - if (*(*shaderSource) != '\n') { - tokenOut[tokenIndex++] = *(*shaderSource); - } - (*shaderSource)++; - } - return false; -} - -// Continue parsing shader source and returns 'true' if an '=' was found -bool shader_file_find_next_uniform_equals_token(char** shaderSource) { - while (*(*shaderSource) != '\0') { - if (*(*shaderSource) == '=') { - (*shaderSource)++; - return true; - } - (*shaderSource)++; - } - return false; -} - -bool shader_file_find_next_uniform_default_value(char** shaderSource, char* tokenOut, bool* semiColonFound) { - tokenOut[0] = '\0'; - - if (semiColonFound) { - *semiColonFound = false; - } - - int tokenIndex = 0; - while (*(*shaderSource) != '\0') { - if (*(*shaderSource) == ';') { - if (semiColonFound) { - *semiColonFound = true; - } - (*shaderSource)++; - tokenOut[tokenIndex] = '\0'; - return true; - } - if (*(*shaderSource) != '\n' && *(*shaderSource) != ' ') { - tokenOut[tokenIndex++] = *(*shaderSource); - } - (*shaderSource)++; - } - return false; -} - -SkaShaderFileParserFunction shader_file_find_next_function(char** shaderSource, const char* functionReturnType) { - SkaShaderFileParserFunction parsedFunction = { .name = NULL, .fullFunctionSource = NULL }; - char shaderFunctionBuffer[1024]; - ska_strcpy(shaderFunctionBuffer, functionReturnType); - ska_strcat(shaderFunctionBuffer, " "); - usize bufferIndex = strlen(shaderFunctionBuffer); - - // Get name first - char shaderFunctionName[64]; - unsigned int shaderFunctionNameIndex = 0; - while (*(*shaderSource) != '\0') { - shaderFunctionBuffer[bufferIndex++] = *(*shaderSource); - if (*(*shaderSource) != ' ') { - shaderFunctionName[shaderFunctionNameIndex++] = *(*shaderSource); - } - (*shaderSource)++; - if (*(*shaderSource) == '(') { - shaderFunctionName[shaderFunctionNameIndex] = '\0'; - break; - } - } - // Now just loop through until we encounter a '}' - usize openBracketsCount = 0; - while (*(*shaderSource) != '\0') { - shaderFunctionBuffer[bufferIndex++] = *(*shaderSource); - (*shaderSource)++; - if (*(*shaderSource) == '{') { - openBracketsCount++; - } else if (*(*shaderSource) == '}') { - shaderFunctionBuffer[bufferIndex++] = *(*shaderSource); - (*shaderSource)++; - openBracketsCount--; - if (openBracketsCount == 0) { - shaderFunctionBuffer[bufferIndex] = '\0'; - break; - } - } - } - - parsedFunction.name = ska_strdup(shaderFunctionName); - parsedFunction.fullFunctionSource = ska_strdup(shaderFunctionBuffer); - return parsedFunction; -} - -// Should have a valid function at this point... -char* shader_file_parse_function_body(const char* functionSource) { - char shaderFunctionBuffer[1024]; - shaderFunctionBuffer[0] = '\0'; - ska_strcpy(shaderFunctionBuffer, functionSource); - unsigned int functionBufferIndex = 0; - char currentToken = shaderFunctionBuffer[functionBufferIndex]; - // Find beginning body - while (currentToken != '{') { - currentToken = shaderFunctionBuffer[++functionBufferIndex]; - } - char functionBodyBuffer[1024]; - unsigned int functionBodyIndex = 0; - currentToken = shaderFunctionBuffer[++functionBufferIndex]; - // Return NULL if an empty function with (with no newlines at least) - if (currentToken == '}') { - return NULL; - } - usize openBracketsCount = 1; - while (openBracketsCount > 0) { - currentToken = shaderFunctionBuffer[functionBufferIndex++]; - functionBodyBuffer[functionBodyIndex++] = currentToken; - if (currentToken == '{') { - openBracketsCount++; - } else if (currentToken == '}') { - openBracketsCount--; - } - } - functionBodyBuffer[functionBodyIndex - 1] = '\n'; - functionBodyBuffer[functionBodyIndex] = '\0'; - - return ska_strdup(functionBodyBuffer); -} - -typedef struct ShaderFileParseVecParseResult { - SkaVector4 vector; - char errorMessage[64]; -} ShaderFileParseVecParseResult; - -// TODO: Refactor and make shorter... -ShaderFileParseVecParseResult shader_file_parse_vec_default_value_token(const char* token) { - ShaderFileParseVecParseResult result = { .vector = { .x = 0.0f, .y = 0.0f, .z = 0.0f, .w = 0.0f }, - .errorMessage = {0} - }; - unsigned int sourceTokenIndex = 4; - char currentFloat2Token = token[sourceTokenIndex]; - // TODO: Add more validation - if (currentFloat2Token != '(') { - ska_strcpy(result.errorMessage, "Didn't find '(' where expected for vec default value!"); - return result; - } - - // Now parse the first vector value - char float2Buffer[16]; - unsigned int float2BufferIndex = 0; - currentFloat2Token = token[++sourceTokenIndex]; - bool hasMoreThanOneValue = false; - while (currentFloat2Token != ')') { - if (currentFloat2Token == ',') { - hasMoreThanOneValue = true; - break; - } - float2Buffer[float2BufferIndex++] = currentFloat2Token; - currentFloat2Token = token[++sourceTokenIndex]; - } - float2Buffer[float2BufferIndex] = '\0'; - result.vector.x = strtof(float2Buffer, NULL); - - // Early out if one value - if (!hasMoreThanOneValue) { - result.vector.y = result.vector.x; - result.vector.z = result.vector.x; - result.vector.w = result.vector.x; - return result; - } - - // Now parse the rest of the values - float* vectorValues[3] = { &result.vector.y, &result.vector.z, &result.vector.w }; - unsigned int vectorValuesIndex = 0; - float2BufferIndex = 0; - currentFloat2Token = token[++sourceTokenIndex]; - // Probably should limit this and have a better termination criterion for loop - while (true) { - if (currentFloat2Token == ',' || currentFloat2Token == ')') { - float2Buffer[float2BufferIndex] = '\0'; - *vectorValues[vectorValuesIndex++] = strtof(float2Buffer, NULL); - if (currentFloat2Token == ')') { - break; - } - float2BufferIndex = 0; - currentFloat2Token = token[++sourceTokenIndex]; - } - float2Buffer[float2BufferIndex++] = currentFloat2Token; - currentFloat2Token = token[++sourceTokenIndex]; - } - - return result; -} - -bool shader_file_is_function_return_type_token(const char* token) { - return strcmp(token, "void") == 0 || strcmp(token, "bool") == 0 || strcmp(token, "int") == 0 - || strcmp(token, "float") == 0 || strcmp(token, "vec2") == 0 || strcmp(token, "vec3") == 0 - || strcmp(token, "vec4") == 0; -} - -typedef struct SEShaderFileParseBaseText { - const char* vertex; - const char* fragment; -} SEShaderFileParseBaseText; - -SEShaderFileParseBaseText shader_file_get_base_shader_text(SkaShaderInstanceType shaderType) { - switch (shaderType) { - case SkaShaderInstanceType_SCREEN: { - return (SEShaderFileParseBaseText) { - .vertex = SKA_OPENGL_SHADER_SOURCE_VERTEX_SCREEN, - .fragment = SKA_OPENGL_SHADER_SOURCE_FRAGMENT_SCREEN - }; - } - case SkaShaderInstanceType_SPRITE: { - return (SEShaderFileParseBaseText) { - .vertex = SKA_OPENGL_SHADER_SOURCE_VERTEX_SPRITE, - .fragment = SKA_OPENGL_SHADER_SOURCE_FRAGMENT_SPRITE - }; - } - default: - break; - } - return (SEShaderFileParseBaseText) { - .vertex = NULL, .fragment = NULL - }; -} - -// TODO: Check to make sure memory is cleaned up on errors -SkaShaderFileParseResult ska_shader_file_parser_parse_shader(const char* shaderSource) { - SkaShaderFileParseResult result = {.errorMessage = {0}}; - char *originalSource = ska_strdup(shaderSource); - char *currentSource = originalSource; - char shaderToken[32]; - bool isSemicolonFound; - result.parseData = (SkaShaderFileParseData) { - .shaderType = SkaShaderInstanceType_INVALID, - .fullVertexSource = NULL, - .fullFragmentSource = NULL, .vertexFunctionSource = NULL, - .fragmentFunctionSource = NULL, - .uniformCount = 0, - .functionCount = 0 - }; - - // Parse shader type - shader_file_find_next_token(¤tSource, shaderToken, &isSemicolonFound); - if (strcmp(shaderToken, "shader_type") != 0) { - SHADER_FILE_PARSER_ERROR_FMT_RETURN(result, originalSource, "Didn't find 'shader_type' first line! Found '%s'", shaderToken); - } - // Parse shader type value - shader_file_find_next_token(¤tSource, shaderToken, &isSemicolonFound); - if (strcmp(shaderToken, "screen") == 0) { - result.parseData.shaderType = SkaShaderInstanceType_SCREEN; - } else if (strcmp(shaderToken, "sprite") == 0) { - result.parseData.shaderType = SkaShaderInstanceType_SPRITE; - } else { - SHADER_FILE_PARSER_ERROR_FMT_RETURN(result, originalSource, "Didn't find 'shader_type' value on first line, instead found '%s'!", shaderToken); - } - - // Parse the rest - while (shader_file_find_next_token(¤tSource, shaderToken, &isSemicolonFound)) { - // UNIFORM VARIABLE - if (strcmp(shaderToken, "uniform") == 0) { -// printf("Parsing shader uniform variable\n"); - SkaShaderParam shaderUniform; - // Parse uniform type - char shaderUniformTypeName[32]; - shader_file_find_next_token(¤tSource, shaderUniformTypeName, &isSemicolonFound); - if (strcmp(shaderUniformTypeName, "bool") == 0) { - shaderUniform.type = SkaShaderParamType_BOOL; - shaderUniform.value.boolValue = false; - } else if (strcmp(shaderUniformTypeName, "int") == 0) { - shaderUniform.type = SkaShaderParamType_INT; - shaderUniform.value.intValue = 0; - } else if (strcmp(shaderUniformTypeName, "float") == 0) { - shaderUniform.type = SkaShaderParamType_FLOAT; - shaderUniform.value.floatValue = 0.0f; - } else if (strcmp(shaderUniformTypeName, "vec2") == 0) { - shaderUniform.type = SkaShaderParamType_FLOAT2; - shaderUniform.value.float2Value = (SkaVector2) { - 0.0f, 0.0f - }; - } else if (strcmp(shaderUniformTypeName, "vec3") == 0) { - shaderUniform.type = SkaShaderParamType_FLOAT3; - shaderUniform.value.float3Value = (SkaVector3) { - 0.0f, 0.0f, 0.0f - }; - } else if (strcmp(shaderUniformTypeName, "vec4") == 0) { - shaderUniform.type = SkaShaderParamType_FLOAT4; - shaderUniform.value.float4Value = (SkaVector4) { - 0.0f, 0.0f, 0.0f, 0.0f - }; - } else { - SHADER_FILE_PARSER_ERROR_FMT_RETURN(result, originalSource, "Expected to find uniform shader type, instead found '%s'!", shaderToken); - } -// printf("type = '%s'\n", shaderUniformTypeName); - // Parse uniform name - char shaderUniformName[32]; - shader_file_find_next_token(¤tSource, shaderUniformName, &isSemicolonFound); - shaderUniform.name = ska_strdup(shaderUniformName); -// printf("name = '%s'\n", shaderUniformName); - // If we didn't find the semicolon, parse for default value - if (!isSemicolonFound) { -// printf("Parsing shader default value\n"); - // Look for '=' - if (!shader_file_find_next_uniform_equals_token(¤tSource)) { - SHADER_FILE_PARSER_ERROR_FMT_RETURN(result, originalSource, "Expected to find an '=' when declaring a uniform variable, instead found '%s'!", shaderToken); - } -// printf("Found '='!\n"); - // Now parse default value - char shaderUniformDefaultValue[32]; - shader_file_find_next_uniform_default_value(¤tSource, shaderUniformDefaultValue, &isSemicolonFound); - if (!isSemicolonFound) { - SHADER_FILE_PARSER_ERROR_FMT_RETURN(result, originalSource, "Expected to find a ';' after declaring a uniform variable's default value, found '%s'!", shaderToken); - } -// printf("shader uniform default value = '%s'\n", shaderUniformDefaultValue); - switch (shaderUniform.type) { - case SkaShaderParamType_BOOL: { - // xor to set to false if default value is either 'false' or '0' - shaderUniform.value.boolValue = !(strcmp(shaderUniformDefaultValue, "false") == 0 || strcmp(shaderUniformDefaultValue, "0") == 0); - break; - } - case SkaShaderParamType_INT: { - char* endptr = NULL; - shaderUniform.value.intValue = (int) strtol(shaderUniformDefaultValue, &endptr, 10); - if (*endptr != '\0') { - SHADER_FILE_PARSER_ERROR_FMT_RETURN(result, originalSource, "Not a valid uniform int default value, found '%s'!", shaderToken); - } - break; - } - case SkaShaderParamType_FLOAT: { - shaderUniform.value.floatValue = strtof(shaderUniformDefaultValue, NULL); - break; - } - case SkaShaderParamType_FLOAT2: { - const ShaderFileParseVecParseResult vectorResult = shader_file_parse_vec_default_value_token(shaderUniformDefaultValue); - shaderUniform.value.float2Value.x = vectorResult.vector.x; - shaderUniform.value.float2Value.y = vectorResult.vector.y; - break; - } - case SkaShaderParamType_FLOAT3: { - const ShaderFileParseVecParseResult vectorResult = shader_file_parse_vec_default_value_token(shaderUniformDefaultValue); - shaderUniform.value.float3Value.x = vectorResult.vector.x; - shaderUniform.value.float3Value.y = vectorResult.vector.y; - shaderUniform.value.float3Value.z = vectorResult.vector.z; - break; - } - case SkaShaderParamType_FLOAT4: { - const ShaderFileParseVecParseResult vectorResult = shader_file_parse_vec_default_value_token(shaderUniformDefaultValue); - shaderUniform.value.float4Value.x = vectorResult.vector.x; - shaderUniform.value.float4Value.y = vectorResult.vector.y; - shaderUniform.value.float4Value.z = vectorResult.vector.z; - shaderUniform.value.float4Value.w = vectorResult.vector.w; - break; - } - default: - break; - } - } - // Finally after all validation checks, add new uniform to array - result.parseData.uniforms[result.parseData.uniformCount++] = shaderUniform; - } else if (shader_file_is_function_return_type_token(shaderToken)) { - SkaShaderFileParserFunction parsedFunction = shader_file_find_next_function(¤tSource, shaderToken); - if (parsedFunction.name == NULL || parsedFunction.fullFunctionSource == NULL) { - SHADER_FILE_PARSER_ERROR_RETURN(result, originalSource, "Didn't successfully parse shader function!"); - } -// printf("function name = '%s'\n", parsedFunction.name); -// printf("function source = '%s'\n", parsedFunction.fullFunctionSource); - // Check for vertex and fragment shader functions - if (strcmp(parsedFunction.name, "vertex") == 0) { - result.parseData.vertexFunctionSource = shader_file_parse_function_body(parsedFunction.fullFunctionSource); - SKA_MEM_FREE(parsedFunction.name); - SKA_MEM_FREE(parsedFunction.fullFunctionSource); - } else if (strcmp(parsedFunction.name, "fragment") == 0) { - result.parseData.fragmentFunctionSource = shader_file_parse_function_body(parsedFunction.fullFunctionSource); - SKA_MEM_FREE(parsedFunction.name); - SKA_MEM_FREE(parsedFunction.fullFunctionSource); - } else { - // Add non vertex and fragment functions to our array - result.parseData.functions[result.parseData.functionCount++] = parsedFunction; - } - } else { - SHADER_FILE_PARSER_ERROR_FMT_RETURN(result, originalSource, "Unexpected token '%s'!", shaderToken); - } - } - - // Now that we've parsed everything create vertex and fragment source text - const char* SHADER_UNIFORMS_REPLACE_TOKEN = "//@@UNIFORMS\n"; - const char* SHADER_FUNCTIONS_REPLACE_TOKEN = "//@@FUNCTIONS\n"; - const char* SHADER_VERTEX_BODY_REPLACE_TOKEN = "//@@vertex()\n"; - const char* SHADER_FRAGMENT_BODY_REPLACE_TOKEN = "//@@fragment()\n"; - const usize SHADER_UNIFORMS_REPLACE_TOKEN_LENGTH = strlen(SHADER_UNIFORMS_REPLACE_TOKEN); - const usize SHADER_FUNCTIONS_REPLACE_TOKEN_LENGTH = strlen(SHADER_FUNCTIONS_REPLACE_TOKEN); - const usize SHADER_VERTEX_BODY_REPLACE_TOKEN_LENGTH = strlen(SHADER_VERTEX_BODY_REPLACE_TOKEN); - const usize SHADER_FRAGMENT_BODY_REPLACE_TOKEN_LENGTH = strlen(SHADER_FRAGMENT_BODY_REPLACE_TOKEN); - - const SEShaderFileParseBaseText shaderBaseText = shader_file_get_base_shader_text(result.parseData.shaderType); - char fullShaderBuffer[4096]; - // Create vertex source - ska_strcpy(fullShaderBuffer, shaderBaseText.vertex); - if (result.parseData.vertexFunctionSource) { - // Vertex uniforms - char* foundUniformsToken = strstr(fullShaderBuffer, SHADER_UNIFORMS_REPLACE_TOKEN); - if (!foundUniformsToken) { - SHADER_FILE_PARSER_ERROR_RETURN(result, originalSource, "Unable to find uniforms token in vertex shader!"); - } - char* uniformsSource = shader_file_parse_data_get_full_uniforms_source(&result.parseData); - if (uniformsSource) { - const usize uniformsReplaceLength = strlen(uniformsSource); - memmove(foundUniformsToken + uniformsReplaceLength, - foundUniformsToken + SHADER_UNIFORMS_REPLACE_TOKEN_LENGTH, - strlen(foundUniformsToken + SHADER_UNIFORMS_REPLACE_TOKEN_LENGTH) + 1); - memcpy(foundUniformsToken, uniformsSource, uniformsReplaceLength); - SKA_MEM_FREE(uniformsSource); - } - // Vertex functions - char* foundFunctionsToken = strstr(fullShaderBuffer, SHADER_FUNCTIONS_REPLACE_TOKEN); - if (!foundFunctionsToken) { - SHADER_FILE_PARSER_ERROR_RETURN(result, originalSource, "Unable to find functions token in vertex shader!"); - } - char* functionsSource = shader_file_parse_data_get_full_functions_source(&result.parseData); - if (functionsSource) { - const usize functionsReplaceLength = strlen(functionsSource); - memmove(foundFunctionsToken + functionsReplaceLength, - foundFunctionsToken + SHADER_FUNCTIONS_REPLACE_TOKEN_LENGTH, - strlen(foundFunctionsToken + SHADER_FUNCTIONS_REPLACE_TOKEN_LENGTH) + 1); - memcpy(foundFunctionsToken, functionsSource, functionsReplaceLength); - SKA_MEM_FREE(functionsSource); - } - // Vertex body - char* foundVertexToken = strstr(fullShaderBuffer, SHADER_VERTEX_BODY_REPLACE_TOKEN); - if (!foundVertexToken) { - SHADER_FILE_PARSER_ERROR_RETURN(result, originalSource, "Unable to find vertex() token in vertex shader!") - } - const usize vertexBodyReplaceLength = strlen(result.parseData.vertexFunctionSource); - memmove(foundVertexToken + vertexBodyReplaceLength, - foundVertexToken + SHADER_VERTEX_BODY_REPLACE_TOKEN_LENGTH, - strlen(foundVertexToken + SHADER_VERTEX_BODY_REPLACE_TOKEN_LENGTH) + 1); - memcpy(foundVertexToken, result.parseData.vertexFunctionSource, vertexBodyReplaceLength); - } -// printf("FULL VERTEX SOURCE = \n%s\n", fullShaderBuffer); - result.parseData.fullVertexSource = ska_strdup(fullShaderBuffer); - - // Create fragment source - ska_strcpy(fullShaderBuffer, shaderBaseText.fragment); - if (result.parseData.fragmentFunctionSource) { - // Fragment uniforms - char* foundUniformsToken = strstr(fullShaderBuffer, SHADER_UNIFORMS_REPLACE_TOKEN); - if (!foundUniformsToken) { - SHADER_FILE_PARSER_ERROR_RETURN(result, originalSource, "Unable to find uniforms token in fragment shader!") - } - char* uniformsSource = shader_file_parse_data_get_full_uniforms_source(&result.parseData); - if (uniformsSource) { - const usize uniformsReplaceLength = strlen(uniformsSource); - memmove(foundUniformsToken + uniformsReplaceLength, - foundUniformsToken + SHADER_UNIFORMS_REPLACE_TOKEN_LENGTH, - strlen(foundUniformsToken + SHADER_UNIFORMS_REPLACE_TOKEN_LENGTH) + 1); - memcpy(foundUniformsToken, uniformsSource, uniformsReplaceLength); - SKA_MEM_FREE(uniformsSource); - } - // Fragment functions - char* foundFunctionsToken = strstr(fullShaderBuffer, SHADER_FUNCTIONS_REPLACE_TOKEN); - if (!foundFunctionsToken) { - SHADER_FILE_PARSER_ERROR_RETURN(result, originalSource, "Unable to find functions token in fragment shader!") - } - char* functionsSource = shader_file_parse_data_get_full_functions_source(&result.parseData); - if (functionsSource) { - const usize functionsReplaceLength = strlen(functionsSource); - memmove(foundFunctionsToken + functionsReplaceLength, - foundFunctionsToken + SHADER_FUNCTIONS_REPLACE_TOKEN_LENGTH, - strlen(foundFunctionsToken + SHADER_FUNCTIONS_REPLACE_TOKEN_LENGTH) + 1); - memcpy(foundFunctionsToken, functionsSource, functionsReplaceLength); - SKA_MEM_FREE(functionsSource); - } - // Fragment body - char* foundFragmentToken = strstr(fullShaderBuffer, SHADER_FRAGMENT_BODY_REPLACE_TOKEN); - if (!foundFragmentToken) { - SHADER_FILE_PARSER_ERROR_RETURN(result, originalSource, "Unable to find fragment() token in fragment shader!") - } - const usize fragmentBodyReplaceLength = strlen(result.parseData.fragmentFunctionSource); - memmove(foundFragmentToken + fragmentBodyReplaceLength, - foundFragmentToken + SHADER_FRAGMENT_BODY_REPLACE_TOKEN_LENGTH, - strlen(foundFragmentToken + SHADER_FRAGMENT_BODY_REPLACE_TOKEN_LENGTH) + 1); - memcpy(foundFragmentToken, result.parseData.fragmentFunctionSource, fragmentBodyReplaceLength); - } -// printf("FULL FRAGMENT SOURCE = \n%s\n", fullShaderBuffer); - result.parseData.fullFragmentSource = ska_strdup(fullShaderBuffer); - - SKA_MEM_FREE(originalSource); - - return result; -} - -void ska_shader_file_parse_clear_parse_result(SkaShaderFileParseResult* result) { - if (result->parseData.fragmentFunctionSource) { - SKA_MEM_FREE(result->parseData.fragmentFunctionSource); - } - if (result->parseData.vertexFunctionSource) { - SKA_MEM_FREE(result->parseData.vertexFunctionSource); - } - if (result->parseData.fullVertexSource) { - SKA_MEM_FREE(result->parseData.fullVertexSource); - } - if (result->parseData.fullFragmentSource) { - SKA_MEM_FREE(result->parseData.fullFragmentSource); - } - for (usize i = 0; i < result->parseData.uniformCount; i++) { - SKA_MEM_FREE(result->parseData.uniforms[i].name); - } - for (usize i = 0; i < result->parseData.functionCount; i++) { - SKA_MEM_FREE(result->parseData.functions[i].name); - SKA_MEM_FREE(result->parseData.functions[i].fullFunctionSource); - } -} diff --git a/old_seika/rendering/shader/shader_file_parser.h b/old_seika/rendering/shader/shader_file_parser.h deleted file mode 100644 index 15cbf7f..0000000 --- a/old_seika/rendering/shader/shader_file_parser.h +++ /dev/null @@ -1,28 +0,0 @@ -#pragma once - -#include "shader_instance.h" - -typedef struct SkaShaderFileParserFunction { - char* name; - char* fullFunctionSource; -} SkaShaderFileParserFunction; - -typedef struct SkaShaderFileParseData { - SkaShaderInstanceType shaderType; - char* fullVertexSource; - char* fullFragmentSource; - char* vertexFunctionSource; - char* fragmentFunctionSource; - usize uniformCount; - usize functionCount; - SkaShaderParam uniforms[32]; - SkaShaderFileParserFunction functions[32]; -} SkaShaderFileParseData; - -typedef struct SkaShaderFileParseResult { - char errorMessage[128]; - SkaShaderFileParseData parseData; -} SkaShaderFileParseResult; - -SkaShaderFileParseResult ska_shader_file_parser_parse_shader(const char* shaderSource); -void ska_shader_file_parse_clear_parse_result(SkaShaderFileParseResult* result); diff --git a/old_seika/rendering/shader/shader_instance.c b/old_seika/rendering/shader/shader_instance.c deleted file mode 100644 index 3fefd90..0000000 --- a/old_seika/rendering/shader/shader_instance.c +++ /dev/null @@ -1,197 +0,0 @@ -#include "shader_instance.h" - -#include -#include - -#include "seika/memory.h" -#include "seika/logger.h" -#include "seika/string.h" -#include "seika/assert.h" - -SkaShaderInstance* ska_shader_instance_create(const char* vertexSource, const char* fragmentSource) { - SkaShader* shader = ska_shader_compile_new_shader(vertexSource, fragmentSource); - // Early out if shader fails to compile - if (shader == NULL) { - return NULL; - } - SkaShaderInstance* instance = SKA_MEM_ALLOCATE(SkaShaderInstance); - instance->shader = shader; - instance->paramMap = ska_string_hash_map_create_default_capacity(); - instance->paramsDirty = true; - return instance; -} - -SkaShaderInstance* ska_shader_instance_create_from_shader(SkaShader* shader) { - SKA_ASSERT(shader != NULL); - SkaShaderInstance* instance = SKA_MEM_ALLOCATE(SkaShaderInstance); - instance->shader = shader; - instance->paramMap = ska_string_hash_map_create_default_capacity(); - instance->paramsDirty = true; - return instance; -} - -void ska_shader_instance_destroy(SkaShaderInstance* shaderInstance) { - SKA_STRING_HASH_MAP_FOR_EACH(shaderInstance->paramMap, iter) { - SkaStringHashMapNode* node = iter.pair; - SkaShaderParam* param = (SkaShaderParam*)node->value; - SKA_MEM_FREE(param->name); - } - ska_string_hash_map_destroy(shaderInstance->paramMap); - ska_shader_destroy(shaderInstance->shader); - SKA_MEM_FREE(shaderInstance); -} - -// Creation functions -void ska_shader_instance_param_create_from_copy(SkaShaderInstance* shaderInstance, SkaShaderParam* param) { - param->name = ska_strdup(param->name); - switch (param->type) { - case SkaShaderParamType_BOOL: { - ska_shader_instance_param_create_bool(shaderInstance, param->name, param->value.boolValue); - return; - } - case SkaShaderParamType_INT: { - ska_shader_instance_param_create_int(shaderInstance, param->name, param->value.intValue); - return; - } - case SkaShaderParamType_FLOAT: { - ska_shader_instance_param_create_float(shaderInstance, param->name, param->value.floatValue); - return; - } - case SkaShaderParamType_FLOAT2: { - ska_shader_instance_param_create_float2(shaderInstance, param->name, param->value.float2Value); - return; - } - case SkaShaderParamType_FLOAT3: { - ska_shader_instance_param_create_float3(shaderInstance, param->name, param->value.float3Value); - return; - } - case SkaShaderParamType_FLOAT4: { - ska_shader_instance_param_create_float4(shaderInstance, param->name, param->value.float4Value); - return; - } - } - SKA_ASSERT_FMT(false, "Failed to copy shader param with name '%s'", param->name); -} - -SkaShaderParam* ska_shader_instance_param_create_bool(SkaShaderInstance* shaderInstance, const char* name, bool value) { - SkaShaderParam params = { .name = ska_strdup(name), .type = SkaShaderParamType_BOOL }; - params.value.boolValue = value; - ska_string_hash_map_add(shaderInstance->paramMap, name, ¶ms, sizeof(SkaShaderParam)); - return (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); -} - -SkaShaderParam* ska_shader_instance_param_create_int(SkaShaderInstance* shaderInstance, const char* name, int32 value) { - SkaShaderParam params = { .name = ska_strdup(name), .type = SkaShaderParamType_INT }; - params.value.intValue = value; - ska_string_hash_map_add(shaderInstance->paramMap, name, ¶ms, sizeof(SkaShaderParam)); - return (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); -} - -SkaShaderParam* ska_shader_instance_param_create_float(SkaShaderInstance* shaderInstance, const char* name, f32 value) { - SkaShaderParam params = { .name = ska_strdup(name), .type = SkaShaderParamType_FLOAT }; - params.value.floatValue = value; - ska_string_hash_map_add(shaderInstance->paramMap, name, ¶ms, sizeof(SkaShaderParam)); - return (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); -} - -SkaShaderParam* ska_shader_instance_param_create_float2(SkaShaderInstance* shaderInstance, const char* name, SkaVector2 value) { - SkaShaderParam params = { .name = ska_strdup(name), .type = SkaShaderParamType_FLOAT2 }; - params.value.float2Value = value; - ska_string_hash_map_add(shaderInstance->paramMap, name, ¶ms, sizeof(SkaShaderParam)); - return (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); -} - -SkaShaderParam* ska_shader_instance_param_create_float3(SkaShaderInstance* shaderInstance, const char* name, SkaVector3 value) { - SkaShaderParam params = { .name = ska_strdup(name), .type = SkaShaderParamType_FLOAT3 }; - params.value.float3Value = value; - ska_string_hash_map_add(shaderInstance->paramMap, name, ¶ms, sizeof(SkaShaderParam)); - return (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); -} - -SkaShaderParam* ska_shader_instance_param_create_float4(SkaShaderInstance* shaderInstance, const char* name, SkaVector4 value) { - SkaShaderParam params = { .name = ska_strdup(name), .type = SkaShaderParamType_FLOAT4 }; - params.value.float4Value = value; - ska_string_hash_map_add(shaderInstance->paramMap, name, ¶ms, sizeof(SkaShaderParam)); - return (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); -} - -// Update functions -void ska_shader_instance_param_update_bool(SkaShaderInstance* shaderInstance, const char* name, bool value) { - SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); - SKA_ASSERT(param->type == SkaShaderParamType_BOOL); - param->value.boolValue = value; - shaderInstance->paramsDirty = true; -} - -void ska_shader_instance_param_update_int(SkaShaderInstance* shaderInstance, const char* name, int32 value) { - SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); - SKA_ASSERT(param->type == SkaShaderParamType_INT); - param->value.intValue = value; - shaderInstance->paramsDirty = true; -} - -void ska_shader_instance_param_update_float(SkaShaderInstance* shaderInstance, const char* name, f32 value) { - SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); - SKA_ASSERT_FMT(param != NULL, "Shader param for '%s' is null!", name); - SKA_ASSERT(param->type == SkaShaderParamType_FLOAT); - param->value.floatValue = value; - shaderInstance->paramsDirty = true; -} - -void ska_shader_instance_param_update_float2(SkaShaderInstance* shaderInstance, const char* name, SkaVector2 value) { - SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); - SKA_ASSERT(param->type == SkaShaderParamType_FLOAT2); - param->value.float2Value = value; - shaderInstance->paramsDirty = true; -} - -void ska_shader_instance_param_update_float3(SkaShaderInstance* shaderInstance, const char* name, SkaVector3 value) { - SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); - SKA_ASSERT(param->type == SkaShaderParamType_FLOAT3); - param->value.float3Value = value; - shaderInstance->paramsDirty = true; -} - -void ska_shader_instance_param_update_float4(SkaShaderInstance* shaderInstance, const char* name, SkaVector4 value) { - SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); - SKA_ASSERT(param->type == SkaShaderParamType_FLOAT4); - param->value.float4Value = value; - shaderInstance->paramsDirty = true; -} - -// Get functions -bool ska_shader_instance_param_get_bool(SkaShaderInstance* shaderInstance, const char* name) { - SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); - SKA_ASSERT(param->type == SkaShaderParamType_BOOL); - return param->value.boolValue; -} - -int32 ska_shader_instance_param_get_int(SkaShaderInstance* shaderInstance, const char* name) { - SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); - SKA_ASSERT(param->type == SkaShaderParamType_INT); - return param->value.intValue; -} - -f32 ska_shader_instance_param_get_float(SkaShaderInstance* shaderInstance, const char* name) { - SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); - SKA_ASSERT(param->type == SkaShaderParamType_FLOAT); - return param->value.floatValue; -} - -SkaVector2 ska_shader_instance_param_get_float2(SkaShaderInstance* shaderInstance, const char* name) { - SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); - SKA_ASSERT(param->type == SkaShaderParamType_FLOAT2); - return param->value.float2Value; -} - -SkaVector3 ska_shader_instance_param_get_float3(SkaShaderInstance* shaderInstance, const char* name) { - SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); - SKA_ASSERT(param->type == SkaShaderParamType_FLOAT3); - return param->value.float3Value; -} - -SkaVector4 ska_shader_instance_param_get_float4(SkaShaderInstance* shaderInstance, const char* name) { - SkaShaderParam* param = (SkaShaderParam*)ska_string_hash_map_get(shaderInstance->paramMap, name); - SKA_ASSERT(param->type == SkaShaderParamType_FLOAT4); - return param->value.float4Value; -} diff --git a/old_seika/rendering/shader/shader_instance.h b/old_seika/rendering/shader/shader_instance.h deleted file mode 100644 index f0e023d..0000000 --- a/old_seika/rendering/shader/shader_instance.h +++ /dev/null @@ -1,72 +0,0 @@ -#pragma once - -/* - * Shader Instance - * --------------------------------------------------------------------------------------------------------------------- - * A work in progress api to create shader instances with parameters. - */ - -#include "shader.h" -#include "seika/data_structures/hash_map_string.h" - -// Shader Param - Shader instance representation of uniform parameters -typedef enum SkaShaderParamType { - SkaShaderParamType_BOOL = 0, - SkaShaderParamType_INT = 1, - SkaShaderParamType_FLOAT = 2, - SkaShaderParamType_FLOAT2 = 3, - SkaShaderParamType_FLOAT3 = 4, - SkaShaderParamType_FLOAT4 = 5, -} SkaShaderParamType; - -typedef struct SkaShaderParam { - char* name; - SkaShaderParamType type; - union { - bool boolValue; - int32 intValue; - f32 floatValue; - SkaVector2 float2Value; - SkaVector3 float3Value; - SkaVector4 float4Value; - } value; -} SkaShaderParam; - -// Shader Instance -typedef enum SkaShaderInstanceType { - SkaShaderInstanceType_INVALID = -1, - SkaShaderInstanceType_SCREEN = 0, - SkaShaderInstanceType_SPRITE = 1, -} SkaShaderInstanceType; - -typedef struct SkaShaderInstance { - SkaShader* shader; - SkaStringHashMap* paramMap; - bool paramsDirty; -} SkaShaderInstance; - -SkaShaderInstance* ska_shader_instance_create(const char* vertexSource, const char* fragmentSource); -SkaShaderInstance* ska_shader_instance_create_from_shader(SkaShader* shader); -void ska_shader_instance_destroy(SkaShaderInstance* shaderInstance); - -void ska_shader_instance_param_create_from_copy(SkaShaderInstance* shaderInstance, SkaShaderParam* param); -SkaShaderParam* ska_shader_instance_param_create_bool(SkaShaderInstance* shaderInstance, const char* name, bool value); -SkaShaderParam* ska_shader_instance_param_create_int(SkaShaderInstance* shaderInstance, const char* name, int32 value); -SkaShaderParam* ska_shader_instance_param_create_float(SkaShaderInstance* shaderInstance, const char* name, f32 value); -SkaShaderParam* ska_shader_instance_param_create_float2(SkaShaderInstance* shaderInstance, const char* name, SkaVector2 value); -SkaShaderParam* ska_shader_instance_param_create_float3(SkaShaderInstance* shaderInstance, const char* name, SkaVector3 value); -SkaShaderParam* ska_shader_instance_param_create_float4(SkaShaderInstance* shaderInstance, const char* name, SkaVector4 value); - -void ska_shader_instance_param_update_bool(SkaShaderInstance* shaderInstance, const char* name, bool value); -void ska_shader_instance_param_update_int(SkaShaderInstance* shaderInstance, const char* name, int32 value); -void ska_shader_instance_param_update_float(SkaShaderInstance* shaderInstance, const char* name, f32 value); -void ska_shader_instance_param_update_float2(SkaShaderInstance* shaderInstance, const char* name, SkaVector2 value); -void ska_shader_instance_param_update_float3(SkaShaderInstance* shaderInstance, const char* name, SkaVector3 value); -void ska_shader_instance_param_update_float4(SkaShaderInstance* shaderInstance, const char* name, SkaVector4 value); - -bool ska_shader_instance_param_get_bool(SkaShaderInstance* shaderInstance, const char* name); -int32 ska_shader_instance_param_get_int(SkaShaderInstance* shaderInstance, const char* name); -f32 ska_shader_instance_param_get_float(SkaShaderInstance* shaderInstance, const char* name); -SkaVector2 ska_shader_instance_param_get_float2(SkaShaderInstance* shaderInstance, const char* name); -SkaVector3 ska_shader_instance_param_get_float3(SkaShaderInstance* shaderInstance, const char* name); -SkaVector4 ska_shader_instance_param_get_float4(SkaShaderInstance* shaderInstance, const char* name); diff --git a/old_seika/rendering/shader/shader_instance_minimal.h b/old_seika/rendering/shader/shader_instance_minimal.h deleted file mode 100644 index 6b426cd..0000000 --- a/old_seika/rendering/shader/shader_instance_minimal.h +++ /dev/null @@ -1,8 +0,0 @@ -#pragma once - -#include "seika/defines.h" - -#define SKA_SHADER_INSTANCE_MAX_INSTANCES 100 -#define SKA_SHADER_INSTANCE_INVALID_ID (SKA_SHADER_INSTANCE_MAX_INSTANCES + 1) - -typedef uint32 SkaShaderInstanceId; diff --git a/old_seika/rendering/shader/shader_source.h b/old_seika/rendering/shader/shader_source.h deleted file mode 100644 index 9c9c8e0..0000000 --- a/old_seika/rendering/shader/shader_source.h +++ /dev/null @@ -1,129 +0,0 @@ -#pragma once - -static const char* SKA_OPENGL_SHADER_SOURCE_VERTEX_SPRITE = - "#version 330 core\n" - "\n" - "layout (location = 0) in float ID;\n" - "layout (location = 1) in vec2 CRE_VERTEX;\n" - "layout (location = 2) in vec2 CRE_TEXTURE_COORDS;\n" - "layout (location = 3) in vec4 CRE_TEXTURE_MODULATE;\n" - "layout (location = 4) in float CRE_APPLY_NEAREST_NEIGHBOR;\n" - "\n" - "out vec2 UV;\n" - "out vec4 TEXTURE_MODULATE;\n" - "out float USING_NEAREST_NEIGHBOR;\n" - "\n" - "uniform float TIME;\n" - "uniform sampler2D TEXTURE;\n" - "uniform mat4 CRE_MODELS[100];\n" - "uniform mat4 CRE_PROJECTION;\n" - "\n" - "//@@UNIFORMS\n" - "\n" - "//@@FUNCTIONS\n" - "\n" - "void main() {\n" - " int CRE_SPRITE_INT_ID = int(ID);\n" - " UV = CRE_TEXTURE_COORDS;\n" - " TEXTURE_MODULATE = CRE_TEXTURE_MODULATE;\n" - " USING_NEAREST_NEIGHBOR = CRE_APPLY_NEAREST_NEIGHBOR;\n" - " vec2 VERTEX = CRE_VERTEX;\n" - " //@@vertex()\n" - " gl_Position = CRE_PROJECTION * CRE_MODELS[CRE_SPRITE_INT_ID] * vec4(VERTEX, 0.0f, 1.0f);\n" - "}\n"; - -static const char* SKA_OPENGL_SHADER_SOURCE_FRAGMENT_SPRITE = - "#version 330 core\n" - "\n" - "in vec2 UV;\n" - "in vec4 TEXTURE_MODULATE;\n" - "in float USING_NEAREST_NEIGHBOR;\n" - "\n" - "out vec4 COLOR;\n" - "\n" - "uniform float TIME;\n" - "uniform sampler2D TEXTURE;\n" - "\n" - "//@@UNIFORMS\n" - "\n" - "vec2 CRE_APPLY_NEAREST_NEIGHBOR(vec2 uv, vec2 texture_size) {\n" - " vec2 pixel = uv * texture_size;\n" - " vec2 seam = floor(pixel + 0.5);\n" - " vec2 dudv = fwidth(pixel);\n" - " pixel = seam + clamp( (pixel - seam) / dudv, -0.5, 0.5);\n" - " return pixel / texture_size;\n" - "}\n" - "\n" - "//@@FUNCTIONS\n" - "\n" - "void main() {\n" - " vec2 TEXTURE_SIZE = textureSize(TEXTURE, 0);\n" - " vec2 CRE_SPRITE_UV = mix(UV, CRE_APPLY_NEAREST_NEIGHBOR(UV, TEXTURE_SIZE), USING_NEAREST_NEIGHBOR);\n" - " COLOR = TEXTURE_MODULATE * texture(TEXTURE, CRE_SPRITE_UV);\n" - " //@@fragment()\n" - "}\n"; - -static const char* SKA_OPENGL_SHADER_SOURCE_VERTEX_FONT = - "#version 330 core\n" - "layout (location = 0) in vec4 vertex; // (pos, tex)\n" - "\n" - "out vec2 texCoords;\n" - "\n" - "uniform mat4 projection;\n" - "\n" - "void main() {\n" - " gl_Position = projection * vec4(vertex.xy, 0.0f, 1.0f);\n" - " texCoords = vertex.zw;\n" - "}\n"; - -static const char* SKA_OPENGL_SHADER_SOURCE_FRAGMENT_FONT = - "#version 330 core\n" - "in vec2 texCoords;\n" - "out vec4 color;\n" - "\n" - "uniform sampler2D textValue;\n" - "uniform vec4 textColor;\n" - "\n" - "void main() {\n" - " vec4 sampled = vec4(1.0f, 1.0f, 1.0f, texture(textValue, texCoords).r);\n" - " color = textColor * sampled;\n" - "}\n"; - -static const char* SKA_OPENGL_SHADER_SOURCE_VERTEX_SCREEN = - "#version 330 core\n" - "layout (location = 0) in vec2 CRE_VERTEX;\n" - "layout (location = 1) in vec2 CRE_TEXTURE_COORDS;\n" - "\n" - "out vec2 UV;\n" - "\n" - "uniform float TIME;\n" - "uniform sampler2D TEXTURE;\n" - "\n" - "//@@UNIFORMS\n" - "\n" - "//@@FUNCTIONS\n" - "\n" - "void main() {\n" - " UV = CRE_TEXTURE_COORDS;\n" - " vec2 VERTEX = CRE_VERTEX;\n" - " //@@vertex()\n" - " gl_Position = vec4(VERTEX, 0.0f, 1.0f);\n" - "}\n"; - -static const char* SKA_OPENGL_SHADER_SOURCE_FRAGMENT_SCREEN = - "#version 330 core\n" - "out vec4 COLOR;\n" - "\n" - "in vec2 UV;\n" - "\n" - "uniform float TIME;\n" - "uniform sampler2D TEXTURE;\n" - "\n" - "//@@UNIFORMS\n" - "\n" - "//@@FUNCTIONS\n" - "\n" - "void main() {\n" - " COLOR = texture(TEXTURE, UV);\n" - " //@@fragment()\n" - "}\n"; diff --git a/old_seika/rendering/texture.c b/old_seika/rendering/texture.c deleted file mode 100644 index 0e6d865..0000000 --- a/old_seika/rendering/texture.c +++ /dev/null @@ -1,152 +0,0 @@ -#include "texture.h" - -#include -#include - -#include - -#include "seika/asset/asset_file_loader.h" -#include "seika/memory.h" -#include "seika/string.h" -#include "seika/assert.h" - -static const struct SkaTexture DEFAULT_TEXTURE_REF = { - .id = 0, - .data = NULL, - .width = 0, - .height = 0, - .nrChannels = 0, - .internalFormat = GL_RGBA, - .imageFormat = GL_RGBA, - .wrapS = GL_CLAMP_TO_BORDER, - .wrapT = GL_CLAMP_TO_BORDER, - .applyNearestNeighbor = true, - .fileName = NULL -}; - -static inline bool ska_texture_is_texture_valid(const SkaTexture* texture) { - return texture != NULL; -} - -static inline SkaTexture* ska_texture_create_default_texture() { - SkaTexture* texture = SKA_MEM_ALLOCATE(SkaTexture); - memcpy(texture, &DEFAULT_TEXTURE_REF, sizeof(SkaTexture)); - return texture; -} - -static void ska_texture_generate(SkaTexture* texture); - -SkaTexture* ska_texture_create_texture(const char* filePath) { - return ska_texture_create_texture2(filePath, DEFAULT_TEXTURE_REF.wrapS, DEFAULT_TEXTURE_REF.wrapT, DEFAULT_TEXTURE_REF.applyNearestNeighbor); -} - -SkaTexture* ska_texture_create_texture2(const char* filePath, GLint wrapS, GLint wrapT, bool applyNearestNeighbor) { - SkaTexture* texture = ska_texture_create_default_texture(); - texture->fileName = ska_strdup(filePath); - texture->wrapS = wrapS; - texture->wrapT = wrapT; - texture->applyNearestNeighbor = applyNearestNeighbor; - // Load image data - SkaAssetFileImageData* fileImageData = ska_asset_file_loader_load_image_data(filePath); - SKA_ASSERT_FMT(fileImageData != NULL, "Failed to load texture image at file path '%s'", filePath); - const usize imageDataSize = strlen((char*) fileImageData->data); - texture->data = (unsigned char*) SKA_MEM_ALLOCATE_SIZE(imageDataSize); -// memcpy(texture->data, fileImageData->data, imageDataSize); - texture->data = fileImageData->data; // TODO: Fix - texture->width = fileImageData->width; - texture->height = fileImageData->height; - texture->nrChannels = fileImageData->nrChannels; - - ska_texture_generate(texture); - - ska_asset_file_loader_free_image_data(fileImageData); - - return texture; -} - -SkaTexture* ska_texture_create_texture_from_memory(const void* buffer, usize bufferSize) { - return ska_texture_create_texture_from_memory2(buffer, bufferSize, DEFAULT_TEXTURE_REF.wrapS, - DEFAULT_TEXTURE_REF.wrapT, DEFAULT_TEXTURE_REF.applyNearestNeighbor); -} - -SkaTexture* ska_texture_create_texture_from_memory2(const void* buffer, usize bufferSize, GLint wrapS, GLint wrapT, bool applyNearestNeighbor) { - SkaTexture* texture = ska_texture_create_default_texture(); - texture->wrapS = wrapS; - texture->wrapT = wrapT; - texture->applyNearestNeighbor = applyNearestNeighbor; - texture->data = (unsigned char*) SKA_MEM_ALLOCATE_SIZE(bufferSize); - unsigned char* imageData = stbi_load_from_memory((unsigned char*)buffer, (int32)bufferSize, &texture->width, &texture->height, &texture->nrChannels, 0); - SKA_ASSERT(imageData); -// memcpy(texture->data, imageData, bufferSize); - texture->data = imageData; - - ska_texture_generate(texture); - - stbi_image_free(imageData); - - return texture; -} - -SkaTexture* ska_texture_create_solid_colored_texture(GLsizei width, GLsizei height, GLuint colorValue) { - SkaTexture* texture = ska_texture_create_default_texture(); - texture->nrChannels = 4; - texture->width = width; - texture->height = height; - - const GLsizei dataSize = width * height * 4; - texture->data = (unsigned char*)SKA_MEM_ALLOCATE_SIZE(dataSize); - for (GLsizei i = 0; i < dataSize; i++) { - texture->data[i] = colorValue; - } - - ska_texture_generate(texture); - - return texture; -} - -void ska_texture_generate(SkaTexture* texture) { - // OpenGL Stuff - if (texture->nrChannels == 1) { - texture->imageFormat = GL_RED; - } else if (texture->nrChannels == 3) { - texture->imageFormat = GL_RGB; - } else if (texture->nrChannels == 4) { - texture->imageFormat = GL_RGBA; - } - - // Create texture - glGenTextures(1, &texture->id); - glBindTexture(GL_TEXTURE_2D, texture->id); - glTexImage2D(GL_TEXTURE_2D, 0, texture->internalFormat, texture->width, texture->height, 0, texture->imageFormat, GL_UNSIGNED_BYTE, texture->data); - glGenerateMipmap(GL_TEXTURE_2D); - // Wrap and filter modes - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, texture->wrapS); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, texture->wrapT); - // Defaults to bilinear interpolation - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - // Unbind texture - glBindTexture(GL_TEXTURE_2D, 0); -} - -void ska_texture_delete(SkaTexture* texture) { - SKA_MEM_FREE(texture->fileName); - SKA_MEM_FREE(texture); -} - -GLint ska_texture_wrap_string_to_int(const char* wrap) { - if (strcmp(wrap, "clamp_to_border") == 0) { - return GL_CLAMP_TO_BORDER; - } else if (strcmp(wrap, "repeat") == 0) { - return GL_REPEAT; - } - return GL_CLAMP_TO_BORDER; -} - -const char* ska_texture_get_wrap_s_string(const SkaTexture* texture) { - return texture->wrapS == GL_REPEAT ? "repeat" : "clamp_to_border"; -} - -const char* ska_texture_get_wrap_t_string(const SkaTexture* texture) { - return texture->wrapT == GL_REPEAT ? "repeat" : "clamp_to_border"; -} diff --git a/old_seika/rendering/texture.h b/old_seika/rendering/texture.h deleted file mode 100644 index f21b428..0000000 --- a/old_seika/rendering/texture.h +++ /dev/null @@ -1,42 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -#include -#include - -#include - -#include "seika/defines.h" - -typedef struct SkaTexture { - GLuint id; - unsigned char* data; - GLsizei width; - GLsizei height; - int32 nrChannels; - // format - GLint internalFormat; - GLint imageFormat; - // configuration - GLint wrapS; - GLint wrapT; - bool applyNearestNeighbor; - char* fileName; -} SkaTexture; - -SkaTexture* ska_texture_create_texture(const char* filePath); -SkaTexture* ska_texture_create_texture2(const char* filePath, GLint wrapS, GLint wrapT, bool applyNearestNeighbor); -SkaTexture* ska_texture_create_texture_from_memory(const void* buffer, usize bufferSize); -SkaTexture* ska_texture_create_texture_from_memory2(const void* buffer, usize bufferSize, GLint wrapS, GLint wrapT, bool applyNearestNeighbor); -SkaTexture* ska_texture_create_solid_colored_texture(GLsizei width, GLsizei height, GLuint colorValue); -void ska_texture_delete(SkaTexture* texture); -GLint ska_texture_wrap_string_to_int(const char* wrap); -const char* ska_texture_get_wrap_s_string(const SkaTexture* texture); -const char* ska_texture_get_wrap_t_string(const SkaTexture* texture); - -#ifdef __cplusplus -} -#endif diff --git a/old_seika/seika.c b/old_seika/seika.c deleted file mode 100644 index f6b834d..0000000 --- a/old_seika/seika.c +++ /dev/null @@ -1,250 +0,0 @@ -#include "seika.h" - -#include - -#include -#include - -#include "flag_utils.h" -#include "logger.h" -#include "input/sdl_input.h" -#include "seika/assert.h" -#include "seika/rendering/renderer.h" -#include "seika/audio/audio_manager.h" -#include "seika/asset/asset_manager.h" - -#define SKA_AUDIO_SOURCE_DEFAULT_WAV_SAMPLE_RATE 44100 -#define SKA_WINDOW_DEFAULT_MAINTAIN_ASPECT_RATIO false - -typedef enum SkaSystemFlag { - SkaSystemFlag_NONE = 0, - SkaSystemFlag_CORE = 1 << 0, - SkaSystemFlag_WINDOW = 2 << 0, - SkaSystemFlag_INPUT = 3 << 0, - SkaSystemFlag_AUDIO = 4 << 0, - SkaSystemFlag_ALL = SkaSystemFlag_CORE | SkaSystemFlag_WINDOW | SkaSystemFlag_INPUT | SkaSystemFlag_AUDIO, -} SkaSystemFlag; - -typedef struct SkaState { - SkaSystemFlag runningSystems; - bool shutdownRequested; -} SkaState; - -static SkaState skaState = { .runningSystems = SkaSystemFlag_NONE, .shutdownRequested = false }; - -static SDL_Window* window = NULL; -static SDL_GLContext openGlContext = NULL; - -bool ska_init() { - if (SKA_HAS_FLAG(SkaSystemFlag_CORE, skaState.runningSystems)) { - return false; - } - - // Set random seed - srand((int)time(NULL)); - - if (SDL_Init(0) != 0) { - return false; - } - - SKA_ADD_FLAGS(skaState.runningSystems, SkaSystemFlag_CORE); - return true; -} - -void ska_shutdown() { - if (SKA_HAS_FLAG(SkaSystemFlag_CORE, skaState.runningSystems)) { - SDL_Quit(); - SKA_REMOVE_FLAGS(skaState.runningSystems, SkaSystemFlag_CORE); - } -} - -bool ska_init_all(const char* title, int32 windowWidth, int32 windowHeight, int32 resolutionWidth, int32 resolutionHeight) { - return ska_init_all2(title, windowWidth, windowHeight, resolutionWidth, resolutionHeight, SKA_AUDIO_SOURCE_DEFAULT_WAV_SAMPLE_RATE, SKA_WINDOW_DEFAULT_MAINTAIN_ASPECT_RATIO); -} - -bool ska_init_all2(const char* title, int32 windowWidth, int32 windowHeight, int32 resolutionWidth, int32 resolutionHeight, uint32 audioWavSampleRate, bool maintainAspectRatio) { - if (!ska_init()) { - return false; - } - - if (!ska_window_init2(title, windowWidth, windowHeight, resolutionWidth, resolutionHeight, maintainAspectRatio)) { - return false; - } - - if (!ska_input_init()) { - return false; - } - - if (!ska_audio_init2(audioWavSampleRate)) { - return false; - } - - ska_asset_manager_initialize(); - - return true; -} - - -void ska_shutdown_all() { - ska_window_shutdown(); - ska_input_shutdown(); - ska_audio_shutdown(); - ska_asset_manager_finalize(); - ska_shutdown(); -} - -void ska_update() { - SKA_ASSERT(SKA_HAS_FLAG(SkaSystemFlag_CORE, skaState.runningSystems)); - ska_input_new_frame(); - - SDL_Event event; - while (SDL_PollEvent(&event)) { - switch(event.type) { - case SDL_EVENT_QUIT: - skaState.shutdownRequested = true; - break; - case SDL_EVENT_WINDOW_RESIZED: { - const Sint32 windowWidth = event.window.data1; - const Sint32 windowHeight = event.window.data2; - ska_renderer_update_window_size(windowWidth, windowHeight); - break; - } - default: { - ska_sdl_process_event(event); - break; - } - } - } - ska_sdl_process_axis_events(); -} - -void ska_fixed_update(f32 deltaTime) { - SKA_ASSERT(SKA_HAS_FLAG(SkaSystemFlag_CORE, skaState.runningSystems)); - - static f32 globalTime = 0.0f; - globalTime += deltaTime; - ska_renderer_set_global_shader_param_time(globalTime); -} - -bool ska_is_running() { - return !skaState.shutdownRequested; -} - -uint32 ska_get_ticks() { - SKA_ASSERT(SKA_HAS_FLAG(SkaSystemFlag_CORE, skaState.runningSystems)); - return (uint32)SDL_GetTicks(); -} - -void ska_delay(uint32 timeToWait) { - SKA_ASSERT(SKA_HAS_FLAG(SkaSystemFlag_CORE, skaState.runningSystems)); - SDL_Delay(timeToWait); -} - -bool ska_set_vsync_enabled(bool enabled) { - SKA_ASSERT(SKA_HAS_FLAG(SkaSystemFlag_CORE, skaState.runningSystems)); - return SDL_GL_SetSwapInterval((int)enabled) == 0; -} - -bool ska_print_errors() { - return ska_logger_internal_print_queue(); -} - -bool ska_window_init(const char* title, int32 windowWidth, int32 windowHeight) { - return ska_window_init2(title, windowWidth, windowHeight, windowWidth, windowHeight, SKA_WINDOW_DEFAULT_MAINTAIN_ASPECT_RATIO); -} - -bool ska_window_init2(const char* title, int32 windowWidth, int32 windowHeight, int32 resolutionWidth, int32 resolutionHeight, bool maintainAspectRatio) { - SKA_ASSERT(SKA_HAS_FLAG(SkaSystemFlag_CORE, skaState.runningSystems)); - if (SKA_HAS_FLAG(SkaSystemFlag_WINDOW, skaState.runningSystems)) { - return false; - } - - if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0) { - return false; - } - - // OpenGL attributes - SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); - SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24); - SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8); - - SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3); - SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3); - SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); - - // Create window - const uint32 windowFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIGH_PIXEL_DENSITY; - window = SDL_CreateWindow( - title, - windowWidth, - windowHeight, - windowFlags - ); - if (!window) { - return false; - } - - // Create OpenGL Context - openGlContext = SDL_GL_CreateContext(window); - - // Initialize Glad - if (!gladLoadGLLoader((GLADloadproc)SDL_GL_GetProcAddress)) { - return false; - } - - // Initialize rendering - ska_renderer_initialize(windowWidth, windowHeight, resolutionWidth, resolutionHeight, maintainAspectRatio); - - SKA_ADD_FLAGS(skaState.runningSystems, SkaSystemFlag_WINDOW); - return true; -} - -void ska_window_shutdown() { - if (SKA_HAS_FLAG(SkaSystemFlag_WINDOW, skaState.runningSystems)) { - SDL_GL_DeleteContext(openGlContext); - SDL_DestroyWindow(window); - SDL_QuitSubSystem(SDL_INIT_VIDEO); - SKA_REMOVE_FLAGS(skaState.runningSystems, SkaSystemFlag_WINDOW); - } -} - -void ska_window_render(const SkaColor* windowBackgroundColor) { - SKA_ASSERT(SKA_HAS_FLAG(SkaSystemFlag_WINDOW, skaState.runningSystems)); - ska_renderer_process_and_flush_batches(windowBackgroundColor); - SDL_GL_SwapWindow(window); -} - -bool ska_input_init() { - SKA_ASSERT(SKA_HAS_FLAG(SkaSystemFlag_CORE, skaState.runningSystems)); - if (SDL_InitSubSystem( SDL_INIT_JOYSTICK | SDL_INIT_GAMEPAD) != 0) { - return false; - } - - if (!ska_sdl_load_gamepad_mappings()) { - return false; - } - - return true; -} - -void ska_input_shutdown() { - if (SKA_HAS_FLAG(SkaSystemFlag_INPUT, skaState.runningSystems)) { - SKA_REMOVE_FLAGS(skaState.runningSystems, SkaSystemFlag_INPUT); - SDL_QuitSubSystem(SDL_INIT_JOYSTICK | SDL_INIT_GAMEPAD); - } -} - -bool ska_audio_init() { - return ska_audio_init2(SKA_AUDIO_SOURCE_DEFAULT_WAV_SAMPLE_RATE); -} - -bool ska_audio_init2(uint32 audioWavSampleRate) { - SKA_ASSERT(SKA_HAS_FLAG(SkaSystemFlag_CORE, skaState.runningSystems)); - return ska_audio_manager_init(audioWavSampleRate); -} - -void ska_audio_shutdown() { - if (SKA_HAS_FLAG(SkaSystemFlag_AUDIO, skaState.runningSystems)) { - SKA_REMOVE_FLAGS(skaState.runningSystems, SkaSystemFlag_AUDIO); - } -} diff --git a/old_seika/seika.h b/old_seika/seika.h deleted file mode 100644 index 59031eb..0000000 --- a/old_seika/seika.h +++ /dev/null @@ -1,38 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" { -#endif - -#include "defines.h" - -struct SkaColor; - -bool ska_init(); -void ska_shutdown(); -bool ska_init_all(const char* title, int32 windowWidth, int32 windowHeight, int32 resolutionWidth, int32 resolutionHeight); -bool ska_init_all2(const char* title, int32 windowWidth, int32 windowHeight, int32 resolutionWidth, int32 resolutionHeight, uint32 audioWavSampleRate, bool maintainAspectRatio); -void ska_shutdown_all(); -void ska_update(); -void ska_fixed_update(f32 deltaTime); -bool ska_is_running(); -uint32 ska_get_ticks(); -void ska_delay(uint32 timeToWait); -bool ska_set_vsync_enabled(bool enabled); -bool ska_print_errors(); - -bool ska_window_init(const char* title, int32 windowWidth, int32 windowHeight); -bool ska_window_init2(const char* title, int32 windowWidth, int32 windowHeight, int32 resolutionWidth, int32 resolutionHeight, bool maintainAspectRatio); -void ska_window_shutdown(); -void ska_window_render(const struct SkaColor* windowBackgroundColor); - -bool ska_input_init(); -void ska_input_shutdown(); - -bool ska_audio_init(); -bool ska_audio_init2(uint32 audioWavSampleRate); -void ska_audio_shutdown(); - -#ifdef __cplusplus -} -#endif \ No newline at end of file diff --git a/old_seika/string.c b/old_seika/string.c deleted file mode 100644 index 0675da8..0000000 --- a/old_seika/string.c +++ /dev/null @@ -1,153 +0,0 @@ -#include "seika/string.h" - -#include -#include -#include - -#include "seika/memory.h" - -#ifdef _MSC_VER -#pragma warning(disable : 4996) // for strcpy and strncat -#endif - -char* ska_strdup(const char* string) { - const usize string_length = strlen(string) + 1; - char* new_string = (char*)SKA_MEM_ALLOCATE_SIZE(string_length); - - if (new_string == NULL) { - return NULL; - } - - return strcpy(new_string, string); -} - -char* ska_strdup_from_memory(void* data, usize size) { - char* newString = (char*)SKA_MEM_ALLOCATE_SIZE(size + 1); - memcpy(newString, data, size); - newString[size] = '\0'; - return newString; -} - -void ska_strcpy(char* destination, const char* source) { - strcpy(destination, source); -} - -bool ska_strncpy(char* destination, usize sizeInBytes, const char* source, usize maxCount) { -#if defined(WIN32) || defined(WIN64) - if (strncpy_s(destination, sizeInBytes, source, maxCount) != 0) { - return false; - } -#else - strncpy(destination, source, maxCount); - if (maxCount > 0) { - destination[maxCount] = '\0'; - } -#endif - return true; -} - -void ska_strcat(char* destination, const char* source) { - strcat(destination, source); -} - -void ska_strncat(char* destination, const char* source, usize sizeInBytes) { - strncat(destination, source, sizeInBytes); -} - - -const char* ska_bool_to_string(bool value) { - return value == true ? "true" : "false"; -} - -char* ska_str_to_lower(char* str) { - for (char* p = str; *p; p++) { - *p = tolower(*p); - } - return str; -} - -char* ska_str_to_lower_and_underscore_whitespace(char* str) { - for (char* p = str; *p; p++) { - if (*p == ' ') { - *p = '_'; - } else { - *p = tolower(*p); - } - } - return str; -} - -unsigned char* ska_str_convert_string_to_unsigned_char(const char* value, usize* outSize) { - const usize stringLength = strlen(value); - *outSize = stringLength + 1; - unsigned char* returnValue = (unsigned char*)SKA_MEM_ALLOCATE_SIZE(*outSize); - for (usize i = 0; i < stringLength; i++) { - returnValue[i] = (unsigned char)value[i]; - } - returnValue[stringLength] = '\0'; - return returnValue; -} - -char* ska_str_trim(const char* value, char delimiter) { - char* newStr; - char* lastExt; - if (value == NULL) { - return NULL; - } - newStr = (char*)SKA_MEM_ALLOCATE_SIZE(strlen(value) + 1); - if (newStr == NULL) { - return NULL; - } - strcpy(newStr, value); - lastExt = strrchr(newStr, delimiter); - if (lastExt != NULL) { - *lastExt = '\0'; - } - return newStr; -} - -void ska_str_trim_by_size(const char* value, char* output, usize size) { - for (usize i = 0; i < size; i++) { - output[i] = value[i]; - } - output[size] = '\0'; -} - -char* ska_str_trim_and_replace(const char* value, char delimiter, const char* replacementValue) { -#define SE_TRIM_PATH_BUFFER 256 - char* newValue = ska_str_trim(value, delimiter); - char pathBuffer[SE_TRIM_PATH_BUFFER]; - strcpy(pathBuffer, newValue); - strcat(pathBuffer, replacementValue); - SKA_MEM_FREE(newValue); - newValue = ska_strdup(pathBuffer); - return newValue; -#undef SE_TRIM_PATH_BUFFER -} - -void ska_str_remove_char(char* string, char charToRemove) { - char* dest = string; - - while (*string) { - if (*string != charToRemove) { - *dest = *string; - dest++; - } - string++; - } - - *dest = '\0'; -} - -char* get_project_archive_name(const char* startingPath) { - if (startingPath == NULL) { - return NULL; - } - char* validPath = ska_str_trim(startingPath, '.'); - char pathBuffer[256]; - strcpy(pathBuffer, validPath); - strcat(pathBuffer, ".zip"); - SKA_MEM_FREE(validPath); - validPath = ska_strdup(pathBuffer); - return validPath; -} diff --git a/old_seika/string.h b/old_seika/string.h deleted file mode 100644 index 99bcdf7..0000000 --- a/old_seika/string.h +++ /dev/null @@ -1,27 +0,0 @@ -#pragma once - -#include "defines.h" - -// Copies string and allocated new memory -char* ska_strdup(const char* string); -// Copies string from a void pointer and allocated new memory -char* ska_strdup_from_memory(void* data, usize size); -void ska_strcpy(char* destination, const char* source); -bool ska_strncpy(char* destination, usize sizeInBytes, const char* source, usize maxCount); -void ska_strcat(char* destination, const char* source); -void ska_strncat(char* destination, const char* source, usize sizeInBytes); -// Conversions - -const char* ska_bool_to_string(bool value); -char* ska_str_to_lower(); -char* ska_str_to_lower_and_underscore_whitespace(char* str); -unsigned char* ska_str_convert_string_to_unsigned_char(const char* value, usize* outSize); - -// Will trim text based on a delimiter and return the string before that -char* ska_str_trim(const char* value, char delimiter); -// Will trim text based on a size and return the string as the 'output' param -void ska_str_trim_by_size(const char* value, char* output, usize size); -// Same as 'ska_str_trim' but will replace the 'delimiter' with the 'replacementValue'. -char* ska_str_trim_and_replace(const char* value, char delimiter, const char* replacementValue); -// Removes all instances of the passed in char from the string -void ska_str_remove_char(char* string, char charToRemove); diff --git a/old_seika/thread/pthread.c b/old_seika/thread/pthread.c deleted file mode 100644 index 61964e1..0000000 --- a/old_seika/thread/pthread.c +++ /dev/null @@ -1,255 +0,0 @@ -#include "pthread.h" - -#ifdef _WIN32 -#include "seika/memory.h" - -typedef struct { - void* (*start_routine)(void*); - void* start_arg; -} win_thread_start_t; - -static DWORD WINAPI win_thread_start(void* arg); -static DWORD timespec_to_ms(const struct timespec *abstime); - -// --- General --- // -int pthread_create(pthread_t* thread, pthread_attr_t* attr, void* (*start_routine)(void*), void* arg) { - win_thread_start_t* data; - - (void) attr; - - if (thread == NULL || start_routine == NULL) { - return 1; // ERROR - } - - data = malloc(sizeof(*data)); - data->start_routine = start_routine; - data->start_arg = arg; - - *thread = CreateThread(NULL, 0, win_thread_start, data, 0, NULL); - if (*thread == NULL) { - return 1; // ERROR - } - return 0; // SUCCESS -} - -int pthread_join(pthread_t thread, void** value_ptr) { - (void) value_ptr; - WaitForSingleObject(thread, INFINITE); - CloseHandle(thread); - return 0; // SUCCESS -} - -int pthread_detach(pthread_t thread) { - // TODO: Process return value - CloseHandle(thread); - return 0; // SUCCESS -} - -int pthread_self() { - return (int) GetCurrentThreadId(); -} - -// --- Mutex --- // -int pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t *attr) { - (void)attr; - - if (mutex == NULL) { - return 1; // ERROR - } - - InitializeCriticalSection(mutex); - return 0; // SUCCESS -} - -int pthread_mutex_destroy(pthread_mutex_t *mutex) { - if (mutex == NULL) { - return 1; // ERROR - } - DeleteCriticalSection(mutex); - return 0; // SUCCESS -} - -int pthread_mutex_lock(pthread_mutex_t *mutex) { - if (mutex == NULL) { - return 1; // ERROR - } - EnterCriticalSection(mutex); - return 0; // SUCCESS -} - -int pthread_mutex_unlock(pthread_mutex_t *mutex) { - if (mutex == NULL) { - return 1; // ERROR - } - LeaveCriticalSection(mutex); - return 0; // SUCCESS -} - - -// --- Conditionals --- // -int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *attr) { - (void) attr; - if (cond == NULL) { - return 1; // ERROR - } - InitializeConditionVariable(cond); - return 0; // SUCCESS -} - -int pthread_cond_destroy(pthread_cond_t* cond) { - // Windows does not have a way to destroy conditionals - (void) cond; - return 0; // SUCCESS -} - -int pthread_cond_wait(pthread_cond_t* cond, pthread_mutex_t *mutex) { - if (cond == NULL || mutex == NULL) { - return 1; // ERROR - } - return pthread_cond_timedwait(cond, mutex, NULL); -} - -int pthread_cond_timedwait(pthread_cond_t* cond, pthread_mutex_t *mutex, const struct timespec *abstime) { - if (cond == NULL || mutex == NULL) { - return 1; // ERROR - } - if (!SleepConditionVariableCS(cond, mutex, timespec_to_ms(abstime))) { - return 1; // ERROR - } - return 0; // SUCCESS -} - -int pthread_cond_signal(pthread_cond_t* cond) { - if (cond == NULL) { - return 1; // ERROR - } - WakeConditionVariable(cond); - return 0; // SUCCESS -} - -int pthread_cond_broadcast(pthread_cond_t* cond) { - if (cond == NULL) { - return 1; // ERROR - } - WakeAllConditionVariable(cond); - return 0; // SUCCESS -} - -// --- Read Write Locks --- // -int pthread_rwlock_init(pthread_rwlock_t* rwlock, const pthread_rwlockattr_t* attr) { - (void) attr; - if (rwlock == NULL) { - return 1; - } - InitializeSRWLock(&(rwlock->lock)); - rwlock->exclusive = false; - return 0; -} - -int pthread_rwlock_destroy(pthread_rwlock_t* rwlock) { - (void) rwlock; - return 0; // SUCCESS -} - -int pthread_rwlock_rdlock(pthread_rwlock_t* rwlock) { - if (rwlock == NULL) { - return 1; // ERROR - } - AcquireSRWLockShared(&(rwlock->lock)); - return 0; // SUCCESS -} - -int pthread_rwlock_tryrdlock(pthread_rwlock_t* rwlock) { - if (rwlock == NULL) { - return 1; // ERROR - } - return !TryAcquireSRWLockShared(&(rwlock->lock)); -} - -int pthread_rwlock_wrlock(pthread_rwlock_t* rwlock) { - if (rwlock == NULL) { - return 1; // ERROR - } - AcquireSRWLockExclusive(&(rwlock->lock)); - rwlock->exclusive = true; - return 0; // SUCCESS -} - -int pthread_rwlock_trywrlock(pthread_rwlock_t* rwlock) { - BOOLEAN ret; - - if (rwlock == NULL) { - return 1; // ERROR - } - - ret = TryAcquireSRWLockExclusive(&(rwlock->lock)); - if (ret) { - rwlock->exclusive = true; - } - return ret; -} - -int pthread_rwlock_unlock(pthread_rwlock_t* rwlock) { - if (rwlock == NULL) { - return 1; // ERROR - } - - if (rwlock->exclusive) { - rwlock->exclusive = false; - ReleaseSRWLockExclusive(&(rwlock->lock)); - } else { - ReleaseSRWLockShared(&(rwlock->lock)); - } - return 0; // SUCCESS -} - - -// --- MISC --- // -static DWORD WINAPI win_thread_start(void* arg) { - win_thread_start_t* data = arg; - void* (*start_routine)(void*) = data->start_routine; - void* start_arg = data->start_arg; - - SKA_MEM_FREE(data); - - start_routine(start_arg); - return 0; // ERROR_SUCCESS -} - -static DWORD timespec_to_ms(const struct timespec *abstime) { - DWORD t; - - if (abstime == NULL) { - return INFINITE; - } - - t = (DWORD) (((abstime->tv_sec - time(NULL)) * 1000) + (abstime->tv_nsec / 1000000)); -// if (t < 0) { -// t = 1; -// } - return t; -} - -//#ifdef _WIN32 -unsigned int pcthread_get_num_procs() { - SYSTEM_INFO sysinfo; - - GetSystemInfo(&sysinfo); - return sysinfo.dwNumberOfProcessors; -} - -#else - -#include -unsigned int pcthread_get_num_procs() { - return (unsigned int)sysconf(_SC_NPROCESSORS_ONLN); -} -#endif - -void ms_to_timespec(struct timespec *ts, uint32 ms) { - if (ts == NULL) { - return; - } - ts->tv_sec = ((long) ms / 1000) + time(NULL); - ts->tv_nsec = ((long) ms % 1000) * 1000000; -} diff --git a/old_seika/thread/pthread.h b/old_seika/thread/pthread.h deleted file mode 100644 index 66dfafa..0000000 --- a/old_seika/thread/pthread.h +++ /dev/null @@ -1,63 +0,0 @@ -#pragma once - -#ifdef _WIN32 -#include -#include -#include - -#else -#include -#endif - -#include "seika/defines.h" - -#ifdef _WIN32 -typedef CRITICAL_SECTION pthread_mutex_t; -typedef void pthread_mutexattr_t; -typedef void pthread_condattr_t; -typedef void pthread_rwlockattr_t; -typedef HANDLE pthread_t; -typedef CONDITION_VARIABLE pthread_cond_t; - -typedef struct { - SRWLOCK lock; - bool exclusive; -} pthread_rwlock_t; - -typedef struct { - int DUMMY_MEMBER; // FIXME: this is only here because of: 'error C2016: C requires that a struct or union have at least one member' -} pthread_attr_t; - -#endif - -#ifdef _WIN32 -int pthread_create(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *arg); -int pthread_join(pthread_t thread, void **value_ptr); -int pthread_detach(pthread_t); -int pthread_self(); - -int pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t *attr); -int pthread_mutex_destroy(pthread_mutex_t *mutex); -int pthread_mutex_lock(pthread_mutex_t *mutex); -int pthread_mutex_unlock(pthread_mutex_t *mutex); - -int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *attr); -int pthread_cond_destroy(pthread_cond_t *cond); -int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); -int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime); -int pthread_cond_signal(pthread_cond_t *cond); -int pthread_cond_broadcast(pthread_cond_t *cond); - -int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr); -int pthread_rwlock_destroy(pthread_rwlock_t *rwlock); -int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); -int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock); -int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock); -int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock); -int pthread_rwlock_unlock(pthread_rwlock_t *rwlock); -#endif - -// Helper functions -unsigned int pcthread_get_num_procs(); - -void ms_to_timespec(struct timespec *ts, uint32 ms); diff --git a/old_seika/thread/thread_pool.c b/old_seika/thread/thread_pool.c deleted file mode 100644 index dc975e3..0000000 --- a/old_seika/thread/thread_pool.c +++ /dev/null @@ -1,184 +0,0 @@ -#include "thread_pool.h" - -#include "seika/memory.h" - -// --- Thread Pool Worker --- // -static SkaThreadPoolWork* tpool_work_create(SkaThreadFunc func, void *arg) { - SkaThreadPoolWork* work; - - if (func == NULL) { - return NULL; - } - - work = SKA_MEM_ALLOCATE_SIZE(sizeof(*work)); - work->func = func; - work->arg = arg; - work->next = NULL; - return work; -} - -static void tpool_work_destroy(SkaThreadPoolWork* work) { - if (work == NULL) { - return; - } - SKA_MEM_FREE(work); -} - - -static SkaThreadPoolWork* tpool_work_get(SkaThreadPool* tp) { - SkaThreadPoolWork* work; - - if (tp == NULL) { - return NULL; - } - - work = tp->workFirst; - if (work == NULL) { - return NULL; - } - - if (work->next == NULL) { - tp->workFirst = NULL; - tp->workLast = NULL; - } else { - tp->workFirst = work->next; - } - - return work; -} - -static void* tpool_worker(void *arg) { - SkaThreadPool* tp = arg; - SkaThreadPoolWork* work; - - while (true) { - pthread_mutex_lock(&(tp->workMutex)); - - while (tp->workFirst == NULL && !tp->shouldStop) { - pthread_cond_wait(&(tp->workCond), &(tp->workMutex)); - } - - if (tp->shouldStop) { - break; - } - - work = tpool_work_get(tp); - tp->workingCount++; - pthread_mutex_unlock(&(tp->workMutex)); - - if (work != NULL) { - work->func(work->arg); - tpool_work_destroy(work); - } - - pthread_mutex_lock(&(tp->workMutex)); - tp->workingCount--; - if (!tp->shouldStop && tp->workingCount == 0 && tp->workFirst == NULL) { - pthread_cond_signal(&(tp->workingCond)); - } - pthread_mutex_unlock(&(tp->workMutex)); - } - - tp->threadCount--; - pthread_cond_signal(&(tp->workingCond)); - pthread_mutex_unlock(&(tp->workMutex)); - return NULL; -} - - -// --- Thread Pool --- // -SkaThreadPool* ska_tpool_create(usize num) { - SkaThreadPool* tp; - pthread_t thread; - - if (num == 0) { - num = 2; - } - - tp = SKA_MEM_ALLOCATE_SIZE_ZERO(1, sizeof(*tp)); - tp->threadCount = num; - - pthread_mutex_init(&(tp->workMutex), NULL); - pthread_cond_init(&(tp->workCond), NULL); - pthread_cond_init(&(tp->workingCond), NULL); - - tp->workFirst = NULL; - tp->workLast = NULL; - - for (usize i = 0; i < num; i++) { - pthread_create(&thread, NULL, tpool_worker, tp); - pthread_detach(thread); - } - - return tp; -} - -void ska_tpool_destroy(SkaThreadPool* tp) { - SkaThreadPoolWork* work; - SkaThreadPoolWork* work2; - - if (tp == NULL) - return; - - pthread_mutex_lock(&(tp->workMutex)); - work = tp->workFirst; - while (work != NULL) { - work2 = work->next; - tpool_work_destroy(work); - work = work2; - } - tp->shouldStop = true; - pthread_cond_broadcast(&(tp->workCond)); - pthread_mutex_unlock(&(tp->workMutex)); - - ska_tpool_wait(tp); - - pthread_mutex_destroy(&(tp->workMutex)); - pthread_cond_destroy(&(tp->workCond)); - pthread_cond_destroy(&(tp->workingCond)); - - SKA_MEM_FREE(tp); -} - -bool ska_tpool_add_work(SkaThreadPool* tp, SkaThreadFunc func, void* arg) { - SkaThreadPoolWork* work; - - if (tp == NULL) { - return false; - } - - work = tpool_work_create(func, arg); - if (work == NULL) { - return false; - } - - pthread_mutex_lock(&(tp->workMutex)); - if (tp->workFirst == NULL) { - tp->workFirst = work; - tp->workLast = tp->workFirst; - } else { - tp->workLast->next = work; - tp->workLast = work; - } - - pthread_cond_broadcast(&(tp->workCond)); - pthread_mutex_unlock(&(tp->workMutex)); - - return true; -} - -void ska_tpool_wait(SkaThreadPool* tp) { - if (tp == NULL) { - return; - } - - pthread_mutex_lock(&(tp->workMutex)); - while (true) { - if ((!tp->shouldStop && tp->workingCount != 0) || (tp->shouldStop && tp->threadCount != 0)) { - pthread_cond_wait(&(tp->workingCond), &(tp->workMutex)); - } else { - break; - } - } - pthread_mutex_unlock(&(tp->workMutex)); -} diff --git a/old_seika/thread/thread_pool.h b/old_seika/thread/thread_pool.h deleted file mode 100644 index 438bd14..0000000 --- a/old_seika/thread/thread_pool.h +++ /dev/null @@ -1,32 +0,0 @@ -#pragma once - -#include -#include - -#include "seika/thread/pthread.h" - -typedef void (*SkaThreadFunc)(void* arg); - -typedef struct SkaThreadPoolWork { - SkaThreadFunc func; - void* arg; - struct SkaThreadPoolWork* next; -} SkaThreadPoolWork; - -typedef struct SkaThreadPool { - SkaThreadPoolWork* workFirst; - SkaThreadPoolWork* workLast; - pthread_mutex_t workMutex; - pthread_cond_t workCond; - pthread_cond_t workingCond; - usize workingCount; - usize threadCount; - bool shouldStop; -} SkaThreadPool; - -SkaThreadPool* ska_tpool_create(usize num); -void ska_tpool_destroy(SkaThreadPool* tp); -// Adds worker (or job) to the thread pool. -bool ska_tpool_add_work(SkaThreadPool* tp, SkaThreadFunc func, void* arg); -// Blocking function that finishes once all work is completed. -void ska_tpool_wait(SkaThreadPool* tp); diff --git a/old_seika/version_info.h b/old_seika/version_info.h deleted file mode 100644 index c429fb7..0000000 --- a/old_seika/version_info.h +++ /dev/null @@ -1,9 +0,0 @@ -#pragma once - -#include "macro_utils.h" - -#define SKA_VERSION_MAJOR 0 -#define SKA_VERSION_MINOR 1 -#define SKA_VERSION_PATCH 7 - -#define SKA_VERSION (SKA_MACRO_TO_STRING(SKA_VERSION_MAJOR) "." SKA_MACRO_TO_STRING(SKA_VERSION_MINOR) "." SKA_MACRO_TO_STRING(SKA_VERSION_PATCH)) diff --git a/seika/version_info.h b/seika/version_info.h index dd543ca..e802b82 100644 --- a/seika/version_info.h +++ b/seika/version_info.h @@ -3,7 +3,7 @@ #include "seika/macro_utils.h" #define SKA_VERSION_MAJOR 0 -#define SKA_VERSION_MINOR 1 -#define SKA_VERSION_PATCH 7 +#define SKA_VERSION_MINOR 2 +#define SKA_VERSION_PATCH 0 #define SKA_VERSION (SKA_MACRO_TO_STRING(SKA_VERSION_MAJOR) "." SKA_MACRO_TO_STRING(SKA_VERSION_MINOR) "." SKA_MACRO_TO_STRING(SKA_VERSION_PATCH)) From eb20b66d1078e431dbe05c419e3673cbbdde16b1 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Sat, 26 Oct 2024 14:07:50 -0400 Subject: [PATCH 45/55] Clean. --- seika/ecs/ec_system.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/seika/ecs/ec_system.h b/seika/ecs/ec_system.h index 59735d8..2d4b3c7 100644 --- a/seika/ecs/ec_system.h +++ b/seika/ecs/ec_system.h @@ -15,7 +15,7 @@ ska_ecs_system_create_from_template_with_signature_string(TEMPLATE, #__VA_ARGS__ #define SKA_ECS_SYSTEM_REGISTER_FROM_TEMPLATE(TEMPLATE, ...) \ ska_ecs_system_register(ska_ecs_system_create_from_template_with_signature_string(TEMPLATE, #__VA_ARGS__)) -#define SKA_ECS_SYSTEM_ENTITIES_FOR(SYSTEM, VALUE) SKA_ARRAY_LIST_FOR_EACH(SYSTEM->list, SkaEntity, VALUE) +#define SKA_ECS_SYSTEM_ENTITIES_FOR(SYSTEM, VALUE) SKA_ARRAY_LIST_FOR_EACH(SYSTEM->entities, SkaEntity, VALUE) struct SkaECSSystem; From c1b0fe1217c585c853d00c231b738fefbb6b7bfc Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Sat, 26 Oct 2024 14:28:42 -0400 Subject: [PATCH 46/55] Updates. --- seika/time.c | 15 +++++++++++++++ seika/time.h | 10 ++++++++++ 2 files changed, 25 insertions(+) create mode 100644 seika/time.c create mode 100644 seika/time.h diff --git a/seika/time.c b/seika/time.c new file mode 100644 index 0000000..da06671 --- /dev/null +++ b/seika/time.c @@ -0,0 +1,15 @@ +#if SKA_INPUT || SKA_RENDERING + +#include "seika/time.h" + +#include + +uint32 ska_get_ticks() { + return (uint32)SDL_GetTicks(); +} + +void ska_delay(uint32 milliseconds) { + SDL_Delay(milliseconds); +} + +#endif // #if SKA_INPUT || SKA_RENDERING diff --git a/seika/time.h b/seika/time.h new file mode 100644 index 0000000..197641f --- /dev/null +++ b/seika/time.h @@ -0,0 +1,10 @@ +#pragma once + +#if SKA_INPUT || SKA_RENDERING + +#include "seika/defines.h" + +uint32 ska_get_ticks(); +void ska_delay(uint32 milliseconds); + +#endif // #if SKA_INPUT || SKA_RENDERING From 842ef61542eea682cdc198917d8993a09cbaa26c Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Sat, 26 Oct 2024 21:57:53 -0400 Subject: [PATCH 47/55] Clean. --- seika/data_structures/array2d.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/seika/data_structures/array2d.c b/seika/data_structures/array2d.c index f6baec1..75fc6e6 100644 --- a/seika/data_structures/array2d.c +++ b/seika/data_structures/array2d.c @@ -49,11 +49,11 @@ void ska_array2d_resize(SkaArray2D* array2d, usize newX, usize newY) { void** oldData = array2d->data; const SkaSize2Di oldSize = array2d->size; // Allocate data for all columns - array2d->data = SKA_ALLOC_BYTES(newHeight * sizeof(void*)); + array2d->data = SKA_ALLOC_BYTES_ZEROED(newHeight * sizeof(void*)); // Iterate over new rows for (usize i = 0; i < newHeight; i++) { // Allocate data for new row - array2d->data[i] = SKA_ALLOC_BYTES(newX * array2d->elementSize); + array2d->data[i] = SKA_ALLOC_BYTES_ZEROED(newX * array2d->elementSize); if (i < (usize)oldSize.h) { // Now copy old data const usize bytesToCopy = SKA_MATH_MIN((usize)oldSize.w, newWidth) * array2d->elementSize; From 7dc34a432c2fabac1d08f4aec0c69a85aa0dcd69 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Sun, 27 Oct 2024 09:54:10 -0400 Subject: [PATCH 48/55] Clean. --- seika/rendering/window.c | 4 ++++ seika/rendering/window.h | 1 + 2 files changed, 5 insertions(+) diff --git a/seika/rendering/window.c b/seika/rendering/window.c index 2a0f59f..f23dd2f 100644 --- a/seika/rendering/window.c +++ b/seika/rendering/window.c @@ -81,4 +81,8 @@ void ska_window_render(const SkaColor* backgroundColor) { SDL_GL_SwapWindow(window); } +bool ska_window_set_vsync(bool enabled) { + return SDL_GL_SetSwapInterval((int)enabled) == 0; +} + #endif // #if SKA_RENDERING diff --git a/seika/rendering/window.h b/seika/rendering/window.h index 4daaa52..5f24a94 100644 --- a/seika/rendering/window.h +++ b/seika/rendering/window.h @@ -18,6 +18,7 @@ typedef struct SkaWindowProperties { bool ska_window_initialize(SkaWindowProperties props); void ska_window_finalize(); void ska_window_render(const struct SkaColor* backgroundColor); +bool ska_window_set_vsync(bool enabled); #endif // #if SKA_RENDERING From 403e970b9558d2345279920324e88bb5b211bd9f Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Sun, 27 Oct 2024 10:03:11 -0400 Subject: [PATCH 49/55] Clean. --- seika/audio/audio.c | 3 ++- seika/audio/audio.h | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/seika/audio/audio.c b/seika/audio/audio.c index ab1d0d6..16b7f89 100644 --- a/seika/audio/audio.c +++ b/seika/audio/audio.c @@ -16,10 +16,11 @@ static bool isAudioInitialized = false; static bool load_wav_data_from_file(const char* file_path, int32* sample_count, int32* channels, int32* sample_rate, void** samples); -void ska_audio_initialize() { +bool ska_audio_initialize() { SKA_ASSERT(isAudioInitialized == false); ska_audio_manager_init(SKA_AUDIO_SOURCE_DEFAULT_WAV_SAMPLE_RATE); isAudioInitialized = true; + return true; } void ska_audio_finalize() { diff --git a/seika/audio/audio.h b/seika/audio/audio.h index bf3bbfe..93f7f02 100644 --- a/seika/audio/audio.h +++ b/seika/audio/audio.h @@ -21,7 +21,7 @@ typedef struct SkaAudioSource { int32 sample_count; } SkaAudioSource; -void ska_audio_initialize(); +bool ska_audio_initialize(); void ska_audio_finalize(); void ska_audio_print_audio_source(SkaAudioSource* audioSource); void ska_audio_set_wav_sample_rate(uint32 wavSampleRate); From 84b366ea579d55b423a96424628bcb596d9c9c45 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Sun, 27 Oct 2024 10:10:54 -0400 Subject: [PATCH 50/55] Update. --- seika/audio/audio_manager.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/seika/audio/audio_manager.c b/seika/audio/audio_manager.c index 33987ba..48d2369 100644 --- a/seika/audio/audio_manager.c +++ b/seika/audio/audio_manager.c @@ -39,7 +39,7 @@ static SkaAudioInstances* audio_instances = NULL; // --- Audio Manager --- // bool ska_audio_manager_init(uint32 wavSampleRate) { - audio_instances = SKA_ALLOC(SkaAudioInstances); + audio_instances = SKA_ALLOC_ZEROED(SkaAudioInstances); pthread_mutex_init(&audio_mutex, NULL); ska_audio_set_wav_sample_rate(wavSampleRate); // Device From d45c9b6347144a9ed9b1c4ff33009ab705819ce7 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Mon, 28 Oct 2024 12:56:00 -0400 Subject: [PATCH 51/55] Clean. --- seika/event.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/seika/event.c b/seika/event.c index 8603a2b..b28dbd8 100644 --- a/seika/event.c +++ b/seika/event.c @@ -7,7 +7,7 @@ //--- Observer ---// SkaObserver* ska_observer_new(SkaObserverOnNotify onNotifyFunc) { SKA_ASSERT(onNotifyFunc != NULL); - SkaObserver* observer = SKA_ALLOC(SkaObserver); + SkaObserver* observer = SKA_ALLOC_ZEROED(SkaObserver); observer->on_notify = onNotifyFunc; return observer; } @@ -18,7 +18,7 @@ void ska_observer_delete(SkaObserver* observer) { //--- Event ---// SkaEvent* ska_event_new() { - SkaEvent* event = SKA_ALLOC(SkaEvent); + SkaEvent* event = SKA_ALLOC_ZEROED(SkaEvent); event->observerCount = 0; return event; } From 1563fbd6f4f49790d1112cf56d915cb51441da90 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Tue, 29 Oct 2024 15:59:03 -0400 Subject: [PATCH 52/55] Clean. --- seika/ecs/component.c | 13 +++++++++---- seika/ecs/component.h | 1 + 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/seika/ecs/component.c b/seika/ecs/component.c index d0b500d..6d1a18b 100644 --- a/seika/ecs/component.c +++ b/seika/ecs/component.c @@ -126,10 +126,7 @@ void* ska_ecs_component_manager_get_component_unchecked(SkaEntity entity, SkaCom } void ska_ecs_component_manager_set_component(SkaEntity entity, SkaComponentIndex index, void* component) { - // Add to component array if entity exceeds size - if ((usize)entity >= componentManager.componentArrays->size) { - ska_array_list_push_back(componentManager.componentArrays, &entity); - } + ska_ecs_component_manager_reserve(entity); ComponentArray* componentArray = ska_array_list_get(componentManager.componentArrays, (usize)entity); component_array_set_component(componentArray, index, component); componentArray->signature |= component_manager_translate_index_to_type(index); @@ -161,6 +158,14 @@ SkaComponentType ska_ecs_component_manager_get_component_signature(SkaEntity ent return componentArray->signature; } +void ska_ecs_component_manager_reserve(SkaEntity lastEntity) { + // Add to component array if entity exceeds size + usize newIndex = (usize)lastEntity; + while (componentManager.componentArrays->size < newIndex) { + ska_array_list_push_back(componentManager.componentArrays, &(ComponentArray){0}); + } +} + SkaComponentType component_manager_translate_index_to_type(SkaComponentIndex index) { SKA_STRING_HASH_MAP_FOR_EACH(componentNameToTypeMap, iter) { SkaStringHashMapNode* node = iter.pair; diff --git a/seika/ecs/component.h b/seika/ecs/component.h index bd67f81..4180227 100644 --- a/seika/ecs/component.h +++ b/seika/ecs/component.h @@ -48,6 +48,7 @@ void ska_ecs_component_manager_remove_all_components(SkaEntity entity); bool ska_ecs_component_manager_has_component(SkaEntity entity, SkaComponentIndex index); void ska_ecs_component_manager_set_component_signature(SkaEntity entity, SkaComponentType componentTypeSignature); SkaComponentType ska_ecs_component_manager_get_component_signature(SkaEntity entity); +void ska_ecs_component_manager_reserve(SkaEntity lastEntity); const char* ska_ecs_component_get_component_data_index_string(SkaComponentIndex index); From 66f02544bd7504111adbe402d4cad319f258cbf0 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Tue, 29 Oct 2024 16:08:19 -0400 Subject: [PATCH 53/55] Clean. --- seika/ecs/component.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/seika/ecs/component.c b/seika/ecs/component.c index 6d1a18b..d25e7ec 100644 --- a/seika/ecs/component.c +++ b/seika/ecs/component.c @@ -161,7 +161,7 @@ SkaComponentType ska_ecs_component_manager_get_component_signature(SkaEntity ent void ska_ecs_component_manager_reserve(SkaEntity lastEntity) { // Add to component array if entity exceeds size usize newIndex = (usize)lastEntity; - while (componentManager.componentArrays->size < newIndex) { + while (componentManager.componentArrays->size <= newIndex) { ska_array_list_push_back(componentManager.componentArrays, &(ComponentArray){0}); } } From 49f311cfa15916e0c22c36ffbc080974e752f3f9 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Tue, 29 Oct 2024 22:38:18 -0400 Subject: [PATCH 54/55] Update. --- seika/ecs/component.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/seika/ecs/component.c b/seika/ecs/component.c index d25e7ec..ee81484 100644 --- a/seika/ecs/component.c +++ b/seika/ecs/component.c @@ -160,7 +160,7 @@ SkaComponentType ska_ecs_component_manager_get_component_signature(SkaEntity ent void ska_ecs_component_manager_reserve(SkaEntity lastEntity) { // Add to component array if entity exceeds size - usize newIndex = (usize)lastEntity; + const usize newIndex = (usize)lastEntity; while (componentManager.componentArrays->size <= newIndex) { ska_array_list_push_back(componentManager.componentArrays, &(ComponentArray){0}); } From 959e7e8675d540aedb495d9fef81e91cae99ddd5 Mon Sep 17 00:00:00 2001 From: Chukobyte Date: Fri, 1 Nov 2024 18:10:27 -0400 Subject: [PATCH 55/55] Clean. --- README.md | 28 +++++++++++++++++++--------- seika/memory.c | 9 ++++++++- 2 files changed, 27 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index d42c320..1d67646 100644 --- a/README.md +++ b/README.md @@ -39,12 +39,12 @@ Seika uses cmake to build. To include in your project, add the following to you include(FetchContent) FetchContent_Declare( - old_seika + seika GIT_REPOSITORY https://github.com/Chukobyte/seika.git - GIT_TAG v0.1.0 + GIT_TAG v0.2.0 ) -FetchContent_MakeAvailable(old_seika) +FetchContent_MakeAvailable(seika) ``` Make sure to link seika to the target with `target_link_libraries`. @@ -64,15 +64,23 @@ A simple example of creating a window and querying for inputs. #include int main(int argv, char** args) { - ska_init_all("Simple Window", 800, 600, 800, 600); - - while (ska_is_running()) { + ska_window_initialize((SkaWindowProperties){ + .title = "Simple Window", + .windowWidth = 800, + .windowHeight = 600, + .resolutionWidth = 800, + .resolutionHeight = 600, + .maintainAspectRatio = true, + }); + ska_input_initialize(); + + while (true) { + // TODO: Need to update this ska_update(); if (ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_ESCAPE, 0)) { break; } - if (ska_input_is_key_just_pressed(SkaInputKey_KEYBOARD_SPACE, 0)) { printf("space just pressed\n"); } @@ -83,10 +91,12 @@ int main(int argv, char** args) { printf("space just released\n"); } - ska_window_render(); + static SkaColor windowBackgroundColor = (SkaColor){ 0.2f, 0.2f, 0.2f, 1.0f }; + ska_window_render(&windowBackgroundColor); } - ska_shutdown_all(); + ska_window_finalize(); + ska_input_finalize(); return 0; } diff --git a/seika/memory.c b/seika/memory.c index 05d539c..5592699 100644 --- a/seika/memory.c +++ b/seika/memory.c @@ -87,7 +87,14 @@ static const SkaMemAllocator defaultAlloc = { .report_leaks = internal_mem_report_leaks }; -static SkaMemAllocator currentAlloc = defaultAlloc; +static SkaMemAllocator currentAlloc = { + .allocate = internal_mem_allocate, + .allocate_zeroed = internal_mem_allocate_zeroed, + .reallocate = internal_mem_reallocate, + .free = internal_mem_free, + .report_leaks = internal_mem_report_leaks +}; + void ska_set_current_allocator(const SkaMemAllocator allocator) { SKA_ASSERT_FMT(isAllocatorValid(&allocator), "Must implement all allocator functions before setting");